diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..2025e1c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*.pyc
+env
+settings.py
+*.orig
+*.csv
diff --git a/DynResource/__init__.py b/DynResource/__init__.py
new file mode 100644
index 0000000..a00e722
--- /dev/null
+++ b/DynResource/__init__.py
@@ -0,0 +1,5 @@
+from dynrestresource import DynRestResource
+from formatter import Formatter
+import dynhelpers
+
+from dynresourcemap import DYN_API_MAP, SUPPORTED_RECORD_TYPES
\ No newline at end of file
diff --git a/DynResource/dynhelpers/__init__.py b/DynResource/dynhelpers/__init__.py
new file mode 100644
index 0000000..270ec40
--- /dev/null
+++ b/DynResource/dynhelpers/__init__.py
@@ -0,0 +1,6 @@
+from dynhelper import DynHelper
+from add import Add
+from update import Update
+from delete import Delete
+from search import Search
+from dynhelpermap import DYN_HELPERS, SUPPORTED_RECORD_TYPES
\ No newline at end of file
diff --git a/DynResource/dynhelpers/add.py b/DynResource/dynhelpers/add.py
new file mode 100644
index 0000000..77f8240
--- /dev/null
+++ b/DynResource/dynhelpers/add.py
@@ -0,0 +1,41 @@
+import logging
+from pprint import pprint, pformat
+
+from dynhelper import DynHelper
+from .. import DynRestResource
+
+
+class Add(DynHelper):
+    
+    #inherit DynectRest init
+    def __init__(self, user, password, account, logger=None):
+        super(Add, self).__init__(user, password, account, logger)
+        
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            global log
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            self.log.addHandler(null_handler)
+
+    def do(self, resource, arg_dict, auto_publish=True):
+
+        log.debug('Add request started')
+        
+        #Sort out fqdn, zone, and hostname provided
+        arg_dict = self._get_zone_from_fqdn(arg_dict)
+        
+        self._log_request_info(resource, arg_dict)
+        
+        dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+        result = dyn.do(resource, 'add', arg_dict, auto_publish)
+        
+        log.info("Request completed")
+        output = result
+        log.debug(pformat(output))
+        
+        return output
\ No newline at end of file
diff --git a/DynResource/dynhelpers/delete.py b/DynResource/dynhelpers/delete.py
new file mode 100644
index 0000000..a0fdd3c
--- /dev/null
+++ b/DynResource/dynhelpers/delete.py
@@ -0,0 +1,66 @@
+import logging
+from pprint import pprint, pformat
+
+from dynhelper import DynHelper
+from .. import DynRestResource
+
+
+class Delete(DynHelper):
+    
+    #inherit DynectRest init
+    def __init__(self, user, password, account, logger=None):
+        super(Delete, self).__init__(user, password, account, logger)
+        
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            global log
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            log.addHandler(null_handler)
+
+
+    def do(self, resource, arg_dict, auto_publish=True):
+
+        log.debug('Delete request started')
+        
+        #Sort out fqdn, zone, and hostname provided
+        arg_dict = self._get_zone_from_fqdn(arg_dict)
+        
+        self._log_request_info(resource, arg_dict)
+        
+        log.debug("Finding records that match fqdn {0}".format(arg_dict['fqdn']))
+        dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+        result_list = dyn.do(resource, 'list', arg_dict, auto_publish)
+        
+        if 'delete_all' in arg_dict.keys():
+            log.info('delete_all flag detected')
+            update_all = arg_dict['delete_all']
+        else:
+            update_all = False
+            
+        if len(result_list['data']) > 1 and delete_all is False:
+            log.warning('Multiple records found, please specify the ID with the -i flag or use the --update_all flag cautiously')
+            output = result_list
+        
+        elif len(result_list['data']) == 1 or delete_all is True:
+            output = []
+            log.debug('Either one record was found, or delete_all flag was used')
+
+            for record in result_list['data']:
+                
+                arg_dict['record_id'] = record.rsplit('/')[-1]
+                log.debug('Deleting record {0}'.format(arg_dict['record_id']))
+                result_delete = dyn.do(resource, 'delete', arg_dict, auto_publish)
+        
+                output.append({
+                    'result': result_delete,
+                })
+        
+        log.info("Request completed")
+        log.debug(pformat(output))
+        
+        return output
\ No newline at end of file
diff --git a/DynResource/dynhelpers/dynhelper.py b/DynResource/dynhelpers/dynhelper.py
new file mode 100644
index 0000000..cd77b6f
--- /dev/null
+++ b/DynResource/dynhelpers/dynhelper.py
@@ -0,0 +1,123 @@
+import logging
+import re
+
+from dynhelpermap import DYN_HELPERS, SUPPORTED_RECORD_TYPES
+
+class DynHelper(object):
+
+    def __init__(self,user,password,account,logger=None):
+        
+        self.user = user
+        self.password = password
+        self.account = account
+        self.logger = logger
+    
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            global log
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            self.log.addHandler(null_handler)
+            
+    def _get_zone_from_fqdn(self,arg_dict):
+        
+        log.debug('Getting Zone from FQDN')
+        
+        if 'zone' not in arg_dict.keys():
+            log.debug('No zone provided, getting zone from FQDN')
+            arg_dict['zone'] = "{0}.{1}".format(arg_dict['fqdn'].rsplit('.')[-2],arg_dict['fqdn'].rsplit('.')[-1])
+            log.info('Zone {0} assumed from FQDN {1}'.format(arg_dict['zone'], arg_dict['fqdn']))
+                
+        return arg_dict
+        
+    def _get_zone_from_zonelink(self, zonelinks, arg_dict):
+        
+        output = []
+        log.debug('Getting zone name from zonelinks list')
+        for zonelink in zonelinks:
+            zone = "{0}".format(zonelink.rsplit('/')[-2])
+            output.append(zone)
+            log.debug('Zone {0} found in zonelink {1}'.format(zone, zonelink))
+            
+        return output
+        
+    def _redact_password(self, arg_dict):
+        
+        log.debug('Redacting password from arg_dict for logging')
+        new_arg_dict = arg_dict
+        
+        if 'password' in arg_dict.keys():
+            new_arg_dict['password'] = "********"
+            log.debug('Password redacted')
+        
+        return new_arg_dict
+        
+    def _log_request_info(self, request, arg_dict):
+        
+        log.debug("Get request info")
+        arg_list = arg_dict.keys()
+        log_data = 'New {0} Request: '.format(request)
+        
+        for arg_item in arg_list:
+            if arg_item not in ['user', 'password', 'account', 'helper_action', 'logger_name' ]:
+                log_data = "{0}{1}={2}, ".format(log_data, arg_item, arg_dict[arg_item])
+                
+        log.info(log_data)
+        
+    def get_record_type(self, original, new_format):
+        
+        log.debug('Getting record type')
+        format_choices = ['short', 'dataset', 'resource', ]
+        if new_format not in format_choices:
+            log.critical("Invalid new_format choice.  Must be 'short', 'dataset', or 'resource'")
+        
+        # long record_type for datasets
+        long_name_dataset = ("{0}_record".format(x.lower()) for x in SUPPORTED_RECORD_TYPES)
+        # long resource_type for resource calls
+        long_name_resource = ("{0}Record".format(x.upper()) for x in SUPPORTED_RECORD_TYPES)
+        
+        if original in SUPPORTED_RECORD_TYPES:
+            original_format = 'short'
+            log.info('Short record type detected')
+        elif original in long_name_dataset:
+            log.info('Long record type detected type')
+            original_format = 'dataset'
+        elif original in long_name_resource:
+            log.info('converted to short long range type')
+            original_format = 'resource'
+        
+        if original_format == new_format:
+            log.debug('Requested record_type is already in desired format')
+            return original
+        
+        else:
+            if new_format == 'short':
+                if original_format == 'dataset':
+                    output = original.split('_')[0].upper()
+                    log.debug("Converted to short format, {0}".format(output))
+                elif original_format == 'resource':
+                    output = re.search('^[A-Z]*', original).group(0)
+                    output = re.sub('R$','$', output)
+                    log.debug("Converted to short format, {0}".format(output))
+            elif new_format == 'dataset':
+                if original_format =='short':
+                    output = "{0}_records".format(original.lower())
+                    log.debug("Converted to dataset format, {0}".format(output))
+                elif original_format == 'resource':
+                    short = re.sub('Record','_records', original)
+                    output = short.lower()
+                    log.debug("Converted to dataset format, {0}".format(output))
+            elif new_format == 'resource':
+                if original_format == 'short':
+                    output = '{0}Record'.format(original)
+                    log.debug("Converted to resource format, {0}".format(output))
+                elif output_format == 'dataset':
+                    short = re.match('^[A-Z]*_', original).group(0).upper()
+                    output = '{0}Record'.format(original)
+                    log.debug("Converted to resource format, {0}".format(output))
+        
+            return output
diff --git a/DynResource/dynhelpers/dynhelpermap.py b/DynResource/dynhelpers/dynhelpermap.py
new file mode 100644
index 0000000..1ce0459
--- /dev/null
+++ b/DynResource/dynhelpers/dynhelpermap.py
@@ -0,0 +1,486 @@
+SUPPORTED_RECORD_TYPES = [
+    'A',
+    'CNAME',
+    'NS',
+    'PTR',
+    'SOA',
+    'TXT',
+    'SPF',
+    'SRV',
+    'MX',
+]
+
+####  Common options ####
+OPT_RECORD_TYPES = {
+    'flag': 'r',
+    'nargs': "*",
+    'choices': SUPPORTED_RECORD_TYPES,
+    'help': 'Record types',
+}
+OPT_ZONES = {
+    'flag': 'z',
+    'nargs': "*",
+    'help': 'Zones to search',
+}
+OPT_ZONE = {
+    'flag': 'z',
+    'help': 'Zones to search',
+}
+OPT_FQDN = {
+    'flag': 1,
+    'help': 'FQDN of record',
+}
+OPT_TTL = {
+    'flag': 't',
+    'help': 'TTL for record',
+}
+OPT_DATAFIELDS = {
+    'flag': 'D',
+    'nargs': "*",
+    'help': 'Datafields you would like to receive in what order',
+}
+OPT_RECORD_ID = {
+    'flag': 'i',
+    'help': 'ID for specific record.  Required if more than one record exists for FQDN',
+}
+OPT_DETAIL = { 'constant': 'Y', 'help': 'Detailed output', }
+OPT_UPDATE_ALL = { 'help': 'Update all records that match', }
+OPT_NOHEADERS = { 'help': 'Do not show headers at top of CSV', }
+OPT_CSV = { 'help': 'Show output as CSV', }
+OPT_YES = { 'help': 'Answer yes to all prompts', }
+OPT_DELETE_ALL = { 'help': 'Delete all matching records', }
+OPT_AS_LIST = { 'help': 'Display data as a Bash-style list, space separated if multiple datafields are requested.', }
+
+#### Not-so-common options ####
+OPT_SERVICE_TYPE = {
+    'flag': 'S',
+    'help': 'Service type to search',
+    'choices': [
+        'HTTPRedirect',
+    ]
+}
+OPT_PORT = {
+    'flag': 'P',
+    'help': 'Indicates the port where the service is running'
+}
+OPT_PRIORITY = {
+    'flag': 'N',
+    'help': 'Numeric value for priority usage. Lower value takes precedence over higher value where two records of the same type exist on the zone/node.'
+}
+OPT_WEIGHT = {
+    'flag': 'W',
+    'help': 'Secondary prioritizing of records to serve. Records of equal priority should be served based on their weight. Higher values are served more often.',
+}
+OPT_CODE = {
+    'flag': 'C',
+    'help': 'HTTP response code to return for redirection',
+    'choices': [
+        '301',
+        '302',
+    ]
+}
+OPT_KEEP_URI = {
+    'flag': 'K',
+    'help': """A flag indicating whether the redirection
+             should include the originally requested URI""",
+    'choices': [
+        'Y',
+        'N',
+    ]
+}
+OPT_SERIAL_STYLE = {
+    'flag': 'S',
+    'help': 'The style in which serial numbers will be generated for the zone',
+    'choices': [
+        'increment',
+        'epoch',
+        'day',
+        'minute',
+    ],
+}
+
+DYN_HELPERS = {}
+DYN_HELPERS['search'] = {
+    'actions': {
+        'records': {
+            'options': {
+                'record_types': OPT_RECORD_TYPES,
+                'zones': OPT_ZONES,
+                'datafields': OPT_DATAFIELDS,
+                'noheaders': OPT_NOHEADERS,
+                'as_list': OPT_AS_LIST,
+                'ttl_min': {
+                    'flag': 'm',
+                    'help': 'Minimum TTL to search for',
+                },
+                'ttl_max': {
+                    'flag': 'M',
+                    'help': 'Maximum TTL to search for',
+                },
+                'csv': {
+                    'flag': False,
+                    'help': "Output as CSV",
+                },
+            },
+        },
+        'changelog': {
+            'options': {
+                'zones': OPT_ZONES,
+                'csv': OPT_CSV,
+                'limit': {
+                    'flag': 'l',
+                    'help': 'Limit the record of numbers to be returned',
+                },
+                'age': {
+                    'flag': 'A',
+                    'help': 'Minimum age of note in hours',
+                },
+            },
+        },
+        'zones': {
+            'options': {
+                'as_list': OPT_AS_LIST,
+            },
+        },
+        'services': {
+            'options': {
+                'service_type': OPT_SERVICE_TYPE,
+                'zone': OPT_ZONE,
+                'detail': OPT_DETAIL,
+            },
+        }
+    },
+    'help': 'Search Dyn Data',
+}
+
+DYN_HELPERS['add'] = {
+    'actions': {
+        'ARecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'address': {
+                    'flag': 'd',
+                    'help': 'Data - IP Address',
+                    'required': True,
+                },
+            },
+            'help': 'Add an A Record',
+        },
+        'CNAMERecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'cname': {
+                    'flag': 'd',
+                    'help': 'Data - CNAME Address to point to',
+                },
+            },
+            'help': 'Add a CNAME Record',
+        },
+        'NSRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'nsdname': {
+                    'flag': 'd',
+                    'help': 'Data - FQDN of Name Server',
+                },
+            },
+            'help': 'Add an NS Record',
+        },
+        'PTRRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'ptrdname': {
+                    'flag': 'd',
+                    'help': 'Data - FQDN Address to point to',
+                },
+            },
+            'help': 'Add a PTR Record',
+        },
+        'TXTRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Data - Free form text',
+                },
+            },
+            'help': 'Add a TXT Record',
+        },
+        'SRVRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'port': OPT_PORT,
+                'priority': OPT_PRIORITY,
+                'weight': OPT_WEIGHT,
+                'target': {
+                    'flag': 'd',
+                    'help': 'Data - The domain name of a host where the service is running on the specified port',
+                },
+            },
+            'help': 'Add an SRV Record',
+        },
+        'MXRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'preference': OPT_PRIORITY,
+                'ttl': OPT_TTL,
+                'exchange': {
+                    'flag': 'd',
+                    'help': 'Hostname of the server responsible for accepting mail messages in the zone',
+                },
+            },
+            'help': 'Add an MX Record',
+        },
+        'HTTPRedirect': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'code': OPT_CODE,
+                'keep_uri': OPT_KEEP_URI,
+                'url': {
+                    'flag': 'd',
+                    'help': 'Data - The URL of the redirect destination'
+                },
+            },
+            'help': 'Add an HTTPRedirect service',
+        },
+    },
+    'help': 'Add stuff',
+}
+
+DYN_HELPERS['update'] = {
+    'actions': {
+        'ARecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'record_id': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'address': {
+                    'flag': 'd',
+                    'help': 'IP Address',
+                },
+            },
+            'help': 'Update an A Record',
+        },
+        'CNAMERecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'record_id': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'cname': {
+                    'flag': 'd',
+                    'help': 'Data - CNAME Address to point to',
+                },
+            },
+            'help': 'Update a CNAME Record',
+        },
+        'NSRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'recordid': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'nsdname': {
+                    'flag': 'd',
+                    'help': 'Data - FQDN of Name Server',
+                },
+            },
+            'help': 'Update an NS Record',
+        },
+        'PTRRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'record_id': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'ptrdname': {
+                    'flag': 'd',
+                    'help': 'Data - FQDN Address to point to',
+                },
+            },
+            'help': 'Update a PTR Record',
+        },
+        'TXTRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'id': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Data - Free form text',
+                },
+            },
+            'help': 'Update a TXT Record',
+        },
+        'SRVRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'port': OPT_PORT,
+                'priority': OPT_PRIORITY,
+                'weight': OPT_WEIGHT,
+                'id': OPT_RECORD_ID,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'target': {
+                    'flag': 'd',
+                    'help': 'Data - The domain name of a host where the service is running on the specified port'
+                },
+            },
+            'help': 'Update an SRV Record',
+        },
+        'MXRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'preference': OPT_PRIORITY,
+                'ttl': OPT_TTL,
+                'id': OPT_RECORD_ID,
+                'yes': OPT_YES,
+                'exchange': {
+                    'flag': 'd',
+                    'help': 'Data - Hostname of the server responsible for accepting mail messages in the zone',
+                },
+            },
+            'help': 'Update an MX Record',
+        },
+        'SOARecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'ttl': OPT_TTL,
+                'serial_style': OPT_SERIAL_STYLE,
+                'update_all': OPT_UPDATE_ALL,
+                'yes': OPT_YES,
+                'rname': {
+                    'flag': 'd',
+                    'help': 'Data - Domain name which specifies the mailbox of the person responsible for this zone',
+                },
+            },
+            'help': 'Update an SOA record',
+        },
+        'HTTPRedirect': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'code': OPT_CODE,
+                'keep_uri': OPT_KEEP_URI,
+                'url': {
+                    'flag': 'd',
+                    'help': 'Data - The URL of the redirect destination'
+                },
+            },
+            'help': 'Update HTTP Redirect service',
+        }
+    },
+    'help': 'Update stuff',
+}
+
+DYN_HELPERS['delete'] = {
+    'actions': {
+        'ARecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete an A Record',
+        },
+        'CNAMERecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete a CNAME Record',
+        },
+        'NSRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete an NS Record',
+        },
+        'PTRRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete a PTR Record',
+        },
+        'TXTRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete a TXT Record',
+        },
+        'SRVRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete an SRV Record',
+        },
+        'MXRecord': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE,
+                'record_id': OPT_RECORD_ID,
+                'delete_all': OPT_DELETE_ALL,
+                'yes': OPT_YES,
+            },
+            'help': 'Delete an MX Record',
+        },
+        'HTTPRedirect': {
+            'options': {
+                'fqdn': OPT_FQDN,
+                'zone': OPT_ZONE
+            },
+            'help': 'Delete HTTPRedirect service',
+        },
+    },
+    'help': 'Delete stuff',
+}
\ No newline at end of file
diff --git a/DynResource/dynhelpers/search.py b/DynResource/dynhelpers/search.py
new file mode 100644
index 0000000..60ae835
--- /dev/null
+++ b/DynResource/dynhelpers/search.py
@@ -0,0 +1,203 @@
+import logging
+import re
+import time
+from pprint import pprint, pformat
+
+from dynhelper import DynHelper
+from .. import DynRestResource
+from ..dynresourcemap import DYN_API_MAP
+
+class Search(DynHelper):
+    
+    #inherit DynectRest init
+    def __init__(self, user, password, account, logger=None):
+        super(Search, self).__init__(user, password, account, logger)
+        
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            global log
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            log.addHandler(null_handler)
+
+
+    def do(self, resource, arg_dict, auto_publish=True):
+
+        log.debug('Search request started')
+        
+        self._log_request_info(resource, arg_dict)
+        
+        if arg_dict['helper_action'] == 'records':
+            log.debug('Searching Records')
+            
+            dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+            
+            # get zone records
+            zone_dict = {}
+            ('Getting zone data')
+            
+            zone_query_dict = arg_dict
+            zone_query_dict['detail'] = True
+            zone_query_dict['resource'] = 'AllRecord'
+            
+            output = {}
+            
+            # Apply any specified filter args to output
+            filter_args = ['record_types', 'datafields', 'ttl_min', 'ttl_max', ]
+            
+            for zone in arg_dict['zones']:
+                output[zone] = {}
+                zone_query_dict['zone'] = zone
+                zone_data = dyn.do('AllRecord', 'list', zone_query_dict, auto_publish)
+                output[zone]['status'] = zone_data['status']
+                output[zone]['job_id'] = zone_data['job_id']
+                output[zone]['msgs'] = zone_data['msgs']
+                output[zone]['data'] = {}
+            
+                if any(x in arg_dict.keys() for x in filter_args):
+                        
+                    if 'record_types' in arg_dict.keys():
+                        log.debug("record_types arg detected")
+                        
+                        record_types = []
+                        for record_type_arg in arg_dict['record_types']:
+                            record_type_arg = self.get_record_type(record_type_arg, 'dataset')
+                            record_types.append(record_type_arg)
+                            
+                    else:
+                        record_types = zone_data['data'].keys()
+                        
+                    for record_type in record_types:
+                        
+                        output[zone]['data'][record_type] = []
+                        
+                        try:
+                        
+                            for record in zone_data['data'][record_type]:
+                                
+                                if ('ttl_min' in arg_dict.keys()) and ('ttl_max' in arg_dict.keys()):
+                                    if (int(record['ttl']) > int(arg_dict['ttl_min'])) and (int(record['ttl']) < int(arg_dict['ttl_max'])):
+                                        output[zone]['data'][record_type].append(record)
+                                    
+                                elif 'ttl_min' in arg_dict.keys():
+                                    if int(record['ttl']) > int(arg_dict['ttl_min']):
+                                            log.debug("ttl for {0}, ttl:{1} is less than {2}, filtering".format(
+                                                record['fqdn'], record['ttl'], arg_dict['ttl_min']))
+                                            output[zone]['data'][record_type].append(record)
+                                    else:
+                                        log.debug("ttl for {0}, ttl:{1} is greater than {2}, keeping".format(
+                                            record['fqdn'], record['ttl'], arg_dict['ttl_min']))
+                                    
+                                elif 'ttl_max' in arg_dict.keys():                    
+                                    if int(record['ttl']) < int(arg_dict['ttl_max']):
+                                            log.debug("ttl for {0}, ttl:{1} is greater than {2}, filtering".format(
+                                                record['fqdn'], record['ttl'], arg_dict['ttl_max']))
+                                            output[zone]['data'][record_type].append(record)
+                                    else:
+                                        log.debug("ttl for {0}, ttl:{1} is less than {2}, keeping".format(
+                                            record['fqdn'], record['ttl'], arg_dict['ttl_max']))
+                                            
+                                else:
+                                    output[zone]['data'][record_type].append(record)
+                                    
+                        except KeyError:
+                            log.info('No {0} found'.format(record_type))
+                        except:
+                            raise
+                                        
+                else:
+                    output[zone]['data'] = zone_data['data']
+                                    
+            return output
+            
+        elif arg_dict['helper_action'] == 'changelog':
+
+            log.info('changelog action specified')
+            dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+            
+            if 'zones' not in arg_dict.keys():
+                log.info('Zones not specified in command, using all zones')
+                zones = dyn.do('Zone', 'list', arg_dict, auto_publish)
+                zones_list = []
+                for zone_link in zones['data']:
+                    zones_list.append(zone_link.rsplit('/')[-2])
+            else:
+                log.debug('Zones specified in command')
+
+            if 'age' not in arg_dict.keys():
+                log.info('No log age defined')
+                arg_dict['age'] = 0
+
+            if 'limit' not in arg_dict.keys():
+                log.info('No log entry limit defined, using last 50 entries')
+                arg_dict['limit'] = 50
+            else:
+                log.debug('Limit of log entries specified at {0}'.format(arg_dict['limit']))
+
+            log.debug('Getting zone notes')
+            
+            zone_notes = {}
+            for zone in arg_dict['zones']:
+                arg_dict['zone'] = zone
+                arg_dict['resource'] = 'ZoneNoteReport'
+                zone_notes[zone] = dyn.do('ZoneNoteReport', 'get', arg_dict, auto_publish)
+            log.info('Zone notes retrieved successfully')
+
+            if arg_dict['age'] == 0:
+                cutoff = 0
+                log.debug('Cutoff age is 0')
+            else:
+                epoch_age = int(arg_dict['age']) * 60 * 60
+                cutoff = int(time.time()) - epoch_age
+                log.debug('Cutoff age is {0}'.format(cutoff))
+            
+            output = {}
+            for zone in arg_dict['zones']:
+                
+                output[zone] = {}
+                output[zone]['data'] = []
+                output[zone]['msgs'] = zone_notes[zone]['msgs']
+                output[zone]['status'] = zone_notes[zone]['status']
+                output[zone]['job_id'] = zone_notes[zone]['job_id']
+                
+                if zone_notes[zone]['data'] is not None:
+                    log.debug('Data was found')
+                    for note in zone_notes[zone]['data']:
+                        log.debug("Analyzing zone note {0}".format(note['timestamp']))
+                        if int(note['timestamp']) > int(cutoff):
+                            log.debug("Note with timestamp {0} was newer than cutoff {1}, appending output".format(note['timestamp'], cutoff))
+                            log.debug("log items for output: {0}".format(len(output[zone]['data'])))
+                            output[zone]['data'].append(note)
+                        else:
+                            log.debug("Note with timestamp {0} older than cuttoff {1}, skipping".format(note['timestamp'], cutoff))
+
+            return output
+        
+        elif arg_dict['helper_action'] == 'zones':
+            log.info('Search zones request received')
+            log.debug('Getting zone list')
+            arg_dict['resource_action'] = 'Zone'
+            arg_dict['resource'] = 'Zone'
+            dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+            output = dyn.do('Zone', 'list', arg_dict, self.logger)
+
+            log.debug('Zone list received')
+
+            return output
+        
+        elif arg_dict['helper_action'] == 'services':
+
+            log.info('Search services request received')
+            arg_dict['resource'] = arg_dict['service_type']
+            
+            dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+
+            log.debug('Making query to dyn')
+            output = dyn.do(arg_dict['service_type'], 'list', arg_dict, self.logger)
+            log.info('Dyn Search Query result received')
+            
+            return output
\ No newline at end of file
diff --git a/DynResource/dynhelpers/update.py b/DynResource/dynhelpers/update.py
new file mode 100644
index 0000000..6248b92
--- /dev/null
+++ b/DynResource/dynhelpers/update.py
@@ -0,0 +1,79 @@
+import logging
+from pprint import pprint, pformat
+
+from dynhelper import DynHelper
+from .. import DynRestResource
+
+
+class Update(DynHelper):
+
+    
+    #inherit DynectRest init
+    def __init__(self, user, password, account, logger=None):
+        super(Update, self).__init__(user, password, account, logger)
+        
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            global log
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            log.addHandler(null_handler)
+
+    def do(self, resource, arg_dict, auto_publish=True):
+
+        log.debug('Update request started')
+        
+        #Sort out fqdn, zone, and hostname provided
+        arg_dict = self._get_zone_from_fqdn(arg_dict)
+        
+        self._log_request_info(resource, arg_dict)
+        
+        log.debug("Finding records that match fqdn {0}".format(arg_dict['fqdn']))
+        dyn = DynRestResource(self.user, self.password, self.account, self.logger)
+        result_list = dyn.do(resource, 'list', arg_dict, auto_publish)
+        
+        if 'update_all' in arg_dict.keys():
+            log.info('update_all flag detected')
+            update_all = arg_dict['update_all']
+        else:
+            update_all = False
+            
+        if len(result_list['data']) > 1 and update_all is False:
+            log.warning('Multiple records found, please specify the ID with the -i flag or use the --update_all flag cautiously')
+            output = result_list
+        
+        elif len(result_list['data']) == 1 or update_all is True:
+            log.debug('Either one record was found, or update_all flag was used')
+
+            output = {}
+
+            for record in result_list['data']:
+                output[record] = {}
+                
+                get_arg_dict = arg_dict.copy()
+                
+                get_arg_dict['record_id'] = record.rsplit('/')[-1]
+                log.debug('Requesting detailed data for existing record')
+                result_get = dyn.do(resource, 'get', get_arg_dict, auto_publish)
+                orig_dict = result_get['data'].copy()
+                
+                update_arg_dict = get_arg_dict.copy()
+                update_arg_dict['resource'] = resource
+                
+                log.debug('Sending update now')
+                result_update = dyn.do(resource, 'update', update_arg_dict, auto_publish)
+                
+                output[record]['status'] = result_update['status']
+                output[record]['data'] = {
+                    'original_record': orig_dict,
+                    'result': result_update,
+                }
+        
+        log.info("Request completed")
+        log.info(pformat(output))
+        
+        return output
diff --git a/DynResource/dynresourcemap.py b/DynResource/dynresourcemap.py
new file mode 100644
index 0000000..fa5d074
--- /dev/null
+++ b/DynResource/dynresourcemap.py
@@ -0,0 +1,892 @@
+#This dictionary serves to map out DynectAPI resources as per their documentation https://help.dyn.com/rest-resources/
+#  This map is meant to be used by the CLI and the library, so some dictionary items may pertain to the CLI only.
+#  The win here is that we don't need to add a new function every time we want to wrap a new API resource.  Instead we just add a new dictionary item here,
+#  and things shoudl just work.
+#
+#  The structure of the dictionary works as follows:
+# [RESOURCE]
+# --[vars]                  #vars are constants related to the Resource.  Common use cases are GET params like 'detail=y' or Booleans
+# ----[<var>]               #the var and it's value.  one line for each var
+# --[actions]               #Actions performed with this resource.
+# ----[<action>]            #Action choice - one block of these per action
+# ------[url_vars]          #URL vars for the resource.  These are mandatory values that are used in the URI part of the REST call
+# ------[method]            #The method used for the REST API Call (GET,PUT,POST,DELETE)
+# ------[rdata]             #Rdata is the DNS data to use in the call.  Set to False if there is no rdata for the resource to send
+# --------[rdata_fields]    #Rdata field and value pairs, one per line
+# ------[options]           #Options are optional items.  There are also some not-so-obvious things that go on here for the CLI
+# --------[<option>]        #An option block, one per option
+# ----------[name]          #For CLI - Name of the option.  NOTE there are some uses cases (Zone) where if the Action name matches this, an option by that name will be created with value set in vars.  Typically Boolean
+# ----------[flag]          #For CLI - Short flag (one letter).  If this is set to false, only a long version is presented and
+# ----[help]                #For CLI - Help string for the action
+SUPPORTED_RECORD_TYPES = [
+    'A',
+    'CNAME',
+    'NS',
+    'PTR',
+    'SOA',
+    'TXT',
+    'SPF',
+    'SRV',
+    'MX',
+]
+
+
+DYN_API_MAP = {}
+DYN_API_MAP['AllRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                }
+            },
+            'help': 'List all records in a zone',
+        },
+    },
+}
+DYN_API_MAP['NSRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List NS records in a zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific NS record in a zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'nsdname': {
+                    'flag': 'd',
+                    'help': 'Hostname of the authoritative Nameserver for the zone',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add NSRecord to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'PUT',
+            'rdata': {
+                'nsdname': {
+                    'flag': 'd',
+                    'help': 'Hostname of the authoritative Nameserver for the zone',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+            },
+            'help': 'Update an NS record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete NSRecord from a zone',
+        },
+    },
+    'help': 'Delete NSRecord from zone',
+}
+DYN_API_MAP['ARecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'help': 'List ARecord that match in a zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'help': 'Get a specific ARecord from a zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'address': {
+                    'flag': 'd',
+                    'help': 'IPv4 Address',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add ARecord to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'address': {
+                    'flag': 'd',
+                    'help': 'IPv4 Address',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an A record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete ARecord from a zone',
+        },
+    },
+}
+DYN_API_MAP['HTTPRedirect'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'GET',
+            'help': 'HTTP Redirect Details',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'options': {
+                'code': {
+                    'flag': 'C',
+                    'help': 'HTTP response code to return for redirection',
+                },
+                'keep_uri': {
+                    'flag': 'K',
+                    'help': """A flag indicating whether the redirection
+                             should include the originally requested URI""",
+                },
+                'url': {
+                    'flag': 'd',
+                    'help': 'The destination URL where the client is sent. Must begin with either http:// or https://',
+                },
+            },
+            'help': 'Creating a new HTTP Redirect service',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'PUT',
+            'options': {
+                'code': {
+                    'flag': 'C',
+                    'help': 'HTTP response code to return for redirection',
+                },
+                'keep_uri': {
+                    'flag': 'K',
+                    'help': 'A flag indicating whether the redirection should include the originally requested URI',
+                },
+                'url': {
+                    'flag': 'd',
+                    'help': 'The target URL where the client is sent. Must begin with either http:// or https://',
+                },
+            },
+            'help': 'Updates an existing HTTP Redirect service on the zone/node indicated.',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'DELETE',
+            'help': 'Deletes an existing HTTP Redirect service from the zone/node indicated.',
+        },
+    },
+}
+DYN_API_MAP['CNAMERecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List CNAME record details',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'help': 'Get a specific CNAMERecord from a zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'cname': {
+                    'flag': 'd',
+                    'help': 'Hostname',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add a CNAME record to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'cname': {
+                    'flag': 'd',
+                    'help': 'Hostname',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an CNAME record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete a CNAME record from a zone',
+        },
+    },
+}
+DYN_API_MAP['PTRRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List PTR records that match fqdn in zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific PTR Record from zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'POST',
+            'rdata': {
+                'ptrdname': {
+                    'flag': 'd',
+                    'help': 'Hostname where the IP address should be directed. Example: mail.example.com',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add an PTR record',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata':  {
+                'ptrdname': {
+                    'flag': 'd',
+                    'help': 'Hostname where the IP address should be directed. Example: mail.example.com',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an PTR record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete a PTR record from a zone',
+        },
+    },
+}
+DYN_API_MAP['TXTRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List TXT records that match fqdn in zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific TXT Record from zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Free form text',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add a TXT record to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Free form text',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an TXT record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete a TXT record from a zone',
+        },
+    },
+}
+DYN_API_MAP['MXRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List MX records that match fqdn in zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific MX Record from zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'exchange': {
+                    'flag': 'd',
+                    'help': 'Hostname of the server responsible for accepting mail messages in the zone',
+                },
+                'preference': {
+                    'flag': 'N',
+                    'help': 'Numeric value for priority usage. Lower value takes precedence over higher value where two records of the same type exist on the zone/node. Default = 10',
+                },
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add an MX record to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'exchange': {
+                    'flag': 'd',
+                    'help': 'Hostname of the server responsible for accepting mail messages in the zone',
+                },
+                'preference': {
+                    'flag': 'N',
+                    'help': 'Numeric value for priority usage. Lower value takes precedence over higher value where two records of the same type exist on the zone/node. Default = 10',
+                },
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an TXT record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete an MX record from a zone',
+        },
+    },
+}
+DYN_API_MAP['SPFRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List SPF records that match fqdn in zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific SPF Record from zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Free text box containing SPF record information',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add a SPF record to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'txtdata': {
+                    'flag': 'd',
+                    'help': 'Free text box containing SPF record information',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Update an SPF record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete a SPF record from a zone',
+        },
+    },
+}
+DYN_API_MAP['SRVRecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List SRV records that match fqdn in zone',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'Get a specific SRV Record from zone',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'rdata': {
+                'port': {
+                    'flag': 'P',
+                    'help': 'Indicates the port where the service is running'
+                },
+                'priority': {
+                    'flag': 'N',
+                    'help': 'Numeric value for priority usage. Lower value takes precedence over higher value where two records of the same type exist on the zone/node.'
+                },
+                'target': {
+                    'flag': 'd',
+                    'help': 'he domain name of a host where the service is running on the specified port'
+                },
+                'weight': {
+                    'flag': 'W',
+                    'help': 'Secondary prioritizing of records to serve. Records of equal priority should be served based on their weight. Higher values are served more often.',
+                },
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                }
+            },
+            'help': 'Add a SRV record to a zone',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'port': {
+                    'flag': 'P',
+                    'help': 'Indicates the port where the service is running',
+                },
+                'priority': {
+                    'flag': 'N',
+                    'help': 'Numeric value for priority usage. Lower value takes precedence over higher value where two records of the same type exist on the zone/node.',
+                },
+                'target': {
+                    'flag': 'd',
+                    'help': 'The domain name of a host where the service is running on the specified port'
+                },
+                'weight': {
+                    'flag': 'W',
+                    'help': 'Secondary prioritizing of records to serve. Records of equal priority should be served based on their weight. Higher values are served more often.',
+                },
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+            },
+            'help': 'Update an SRV record',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'DELETE',
+            'help': 'Delete a SRV record from a zone',
+        },
+    },
+}
+DYN_API_MAP['SOARecord'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'List of matching SOARecords',
+                },
+            },
+            'help': 'List PTR record details',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'GET',
+            'options': {
+                'detail': {
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },
+            },
+            'help': 'List PTR record details',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'record_id'],
+            'method': 'PUT',
+            'rdata': {
+                'rname': {
+                    'flag': 'd',
+                    'help': 'Domain name which specifies the mailbox of the person responsible for this zone',
+                }
+            },
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+                'serial_style': {
+                    'flag': 'S',
+                    'help': 'The style in which serial numbers will be generated for the zone',
+                    'choices': [
+                        'increment',
+                        'epoch',
+                        'day',
+                        'minute',
+                    ],
+                }
+            },
+            'help': 'Update an SOA record',
+        },
+    },
+}
+DYN_API_MAP['Zone'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource'],
+            'method': 'GET',
+            'help': 'List of all zones',
+        },
+        'get': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'GET',
+            'help': 'List of all zones',
+            'options': {
+                'detail': {
+                    'flag': False,
+                    'constant': 'y',
+                    'help': 'Provides extra detail about each record',
+                },   
+            },
+        },
+        'add': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'POST',
+            'options': {
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+                'rname': {
+                    'flag': 'd',
+                    'help': 'Administrative contact for this zone',
+                },
+            },
+            'help': 'Add a new zone',
+        },
+        'publish': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'PUT',
+            'options': {
+                'publish': {
+                    'constant': True,
+                    'help': 'Publish changes to a zone',
+                }
+            },
+            'help': 'Publish changes to a zone',
+        },
+        'thaw': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'PUT',
+            'options': {
+                'thaw': {
+                    'constant': True,
+                    'help': 'Unfreeze a zone',
+                }
+            },
+            'help': 'Unfreeze a zone to allow changes',
+        },
+        'freeze': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'PUT',
+            'options': {
+                'freeze': {
+                    'constant': True,
+                    'help': 'Freeze a zone to prevent chnages',
+                }
+            },
+            'help': 'Freeze a zone to stop changes',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'DELETE',
+            'help': 'Delete a zone',
+        },
+    },
+}
+DYN_API_MAP['ZoneTransfer'] = {
+    'actions': {
+        'status': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'GET',
+            'help': 'Check the status of a zone transfer job',
+        },
+        'start': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'POST',
+            'options': {
+                'master_ip': {
+                    'flag': 'd',
+                    'help': 'IP address of the master server where the zone data exists',
+                }
+            },
+            'help': 'Start a zone transfer for a zone',
+        },
+        'retry': {
+            'url_vars': ['resource', 'zone'],
+            'method': 'PUT',
+            'options': {
+                'master_ip': {
+                    'flag': 'd',
+                    'help': 'IP address of the master server where the zone data exists',
+                }
+            },
+            'help': 'Retry a failed zone transfer',
+        },
+    },
+}
+DYN_API_MAP['IPTrack'] = {
+    'actions': {
+        'list': {
+            'url_vars': ['resource', 'fqdn'],
+            'method': 'GET',
+            'help': 'Retrieves all instances of the IPTrack service on the zone/node indicated',
+        },
+        'add': {
+            'url_vars': ['resource', 'zone', 'fqdn'],
+            'method': 'POST',
+            'options': {
+                'record_types': {
+                    'flag': 'r',
+                    'help': 'Type of records to track (array)',
+                },
+                'hosts': {
+                    'flag': 'd',
+                    'nargs': '*',
+                    'help': 'Hostnames of the zones where you want to track records (array)',
+                },
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+                'netmask': {
+                    'flag': 'n',
+                    'help': 'A netmask to match A/AAAA rdata against. Matched records will get PTR records, others will not',
+                },
+            },
+            'help': 'Creates a new instance of the IPTrack service on the zone/node indicated.',
+        },
+        'update': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'service_id'],
+            'method': 'PUT',
+            'options': {
+                'record_types': {
+                    'flag': 'r',
+                    'help': 'Type of records to track (array)',
+                },
+                'hosts': {
+                    'flag': 'd',
+                    'nargs': '*',
+                    'help': 'Hostnames of the zones where you want to track records (array)',
+                },
+                'ttl': {
+                    'flag': 't',
+                    'help': 'Time To Live for Record',
+                },
+                'netmask': {
+                    'flag': 'n',
+                    'help': 'A netmask to match A/AAAA rdata against. Matched records will get PTR records, any others will not',
+                },
+                'activate': {
+                    'help': 'Activate policy',
+                },
+                'deactivate': {
+                    'help': 'Deactivate policy',
+                },
+            },
+            'help': 'Updates an existing instance of the IPTrack service on the zone/node indicated.',
+        },
+        'delete': {
+            'url_vars': ['resource', 'zone', 'fqdn', 'service_id'],
+            'method': 'DELETE',
+            'help': 'Deletes an existing instance of the IPTrack service on the zone/node indicated',
+        },
+    },
+}
+DYN_API_MAP['ZoneNoteReport'] = {
+    'actions': {
+        'get': {
+            'url_vars': ['resource'],
+            'method': 'POST',
+            'options': {
+                'zone': {
+                    'flag': 'z',
+                    'help': 'Zone to get notes from',
+                },
+                'limit': {
+                    'flag': 'l',
+                    'help': 'The number of notes to be retrieved.  Limit 1000 notes'
+                },
+                'offset': {
+                    'flag': 'o',
+                    'help': 'Count of the most recent notes to skip. Defaults to 0'
+                },
+            },
+            'help': 'Get a report of zone notes',
+        },
+    },
+}
diff --git a/DynResource/dynrestresource.py b/DynResource/dynrestresource.py
new file mode 100644
index 0000000..3072d3c
--- /dev/null
+++ b/DynResource/dynrestresource.py
@@ -0,0 +1,241 @@
+import logging
+from pprint import pformat
+import re
+from time import sleep
+
+from dynect import DynectRest
+from dynresourcemap import DYN_API_MAP
+
+
+class DynRestResource(DynectRest):
+    
+    request_uri = '/REST/'
+    logged_in = False
+    
+    def __init__(self,user,password,account,logger=None):
+        
+        #inherit DynectRest init
+        super(DynRestResource, self).__init__()
+        
+        self.user = user
+        self.password = password
+        self.account = account
+        
+        global log
+
+        #if logger name is specified, log commands will log to it
+        if logger is not None:
+            parent_logger = logger
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            log.addHandler(null_handler)
+    
+    
+    def login(self):
+        try:
+            log.debug('Connecting to Dynect API')
+            login = self.execute(
+                '/REST/Session/', 
+                'POST',
+                {
+                    'customer_name': self.account,
+                    'user_name': self.user, 'password': self.password
+                }
+            )
+
+            if login['status'] != 'success':
+                log.critical = 'Login Failed! \n'
+            
+            self.logged_in = True
+            
+            log.debug('Login Successful')
+            return 0
+        except Exception:
+
+            log.exception('Connection to Dynect API failed')
+            raise
+        
+
+    def _job_status(
+        self, 
+        job_id, 
+        counter=0, 
+        standoff=1, 
+        max_attempts=10,
+        standoff_multiplier=2
+    ):
+
+        log.debug('Checking job status')
+        sleep(standoff)
+
+        try:
+            result = self.execute('/REST/Job/{0}/'.format(job_id), 'GET', {})
+
+            if result['status'] not in ['success', 'failure']:
+                log.info('Job status has not returned yet, retrying')
+                if counter > max_attempts:
+                    log.warning('Maximum attempts to check job status have failed')
+                    response = raw_input("Do you wish to continue waiting?[Y/n]")
+                    if response in ['n', 'N']:
+                        log.critical(
+                            'User terminated process after maximum attempts at checking job status were reached.'
+                        )
+                    else:
+                        log.info('User chose to continue waiting on job status')
+                        counter = 0
+                else:
+                    counter += 1
+
+                standoff = standoff * multiplier
+                _job_status(counter=counter, standoff=standoff)
+                
+            log.info('Job status check completed')
+            return 0
+            
+        except Exception, e:
+            log.exception('Failed to check job status\n{0}'.format(e))
+            raise
+
+
+    # publish the changes made by the CLI after call automatically
+    def _auto_publish(self,zone):
+        log.debug('Running Auto Publish')
+        result = self.execute('/REST/Zone/{0}/'.format(zone),
+                                  'PUT', {'publish': True})
+        log.debug('Changes to {0} has been published'.format(zone))
+        return 0
+        
+        
+    def do(self, resource, action, arg_dict, auto_publish=True):
+        
+        log.debug("resource: {0}, action {1}".format(resource, action))
+        log_arg_dict = arg_dict
+        if 'password' in log_arg_dict.keys():
+            log_arg_dict['password'] = "***********"
+        log.debug("arg_dict: {0}".format(log_arg_dict))
+        
+        # get the resource map for the chosen resource
+        log.debug("Retrieving resource action map")
+        action_map = DYN_API_MAP[resource]['actions'][action]
+        log.debug("Loaded action map for {0} resource {1} action".format(resource,action))
+        log.debug(pformat(action_map))
+        
+        #build field lists for resource
+        all_fields = []
+        
+        log.debug("Gathering URL variables")
+        url_var_list = []
+        if 'url_vars' in action_map.keys():
+            for url_var in action_map['url_vars']:
+                url_var_list.append(url_var)
+                all_fields.append(url_var)
+        log.debug("url_var_list: {0}".format(url_var_list))
+        
+        log.debug("Gathering Option variables")
+        if 'options' in action_map.keys():
+            option_list = action_map['options'].keys()
+        else:
+            option_list = []
+        log.debug("option list: {0}".format(option_list))
+        
+        log.debug("Gathering rdata variables")
+        if 'rdata' in action_map.keys():
+            rdata_list = action_map['rdata'].keys()
+        else:
+            rdata_list = []
+        log.debug("rdata list: {0}".format(rdata_list))
+        
+        log.debug("all_fields list: {0}".format(all_fields))
+        # build out the URL/URI for the api call
+        
+        log.debug('Building URL for call')
+        request_uri = self.request_uri
+        for url_var in url_var_list:
+            request_uri = "{0}{1}/".format(request_uri,arg_dict[url_var])
+
+        # set the HTTP method used for the call
+        method = action_map['method']
+
+        # if the call is a GET method, options become GET params.
+        #  Currently only used for 'detail' option
+        if (method == 'GET'):
+            log.debug('Request using GET method')
+            if len(option_list) > 0:
+                
+                request_uri = "{0}?".format(request_uri)
+                first_item = True
+
+                for option_name in option_list:
+                    
+                    option = action_map['options'][option_name]
+                    
+                    if first_item is True:
+                        first_item = False
+                    else:
+                        request_uri = "{0}&".format(request_uri)
+
+                    # if constant value is set, use that
+                    if 'constant' in option.keys():
+                        if option_name in arg_dict.keys():
+                            if arg_dict[option_name] is True:
+                                request_uri = "{0}{1}={2}".format(request_uri,option_name,option['constant'])
+                    elif option_name in arg_dict.keys():
+                        request_uri = "{0}{1}={2}".format(request_uri,option_name,arg_dict[option_name])
+                        
+            log.info('Request URI: {0}'.format(request_uri))
+            post_data = {}
+            
+            
+        # for all other HTTP methods
+        # if there is rdata, add it to the data dictionary for the api call
+        else:
+            log.debug('Request is not type GET')
+            post_data = {}
+            
+            if resource != 'ZoneNoteReport':
+                log.debug('Resource is not ZoneNoteReport')
+                post_data['rdata'] = {} 
+            
+                log.debug("Adding rdata to postargs")
+                if len(rdata_list) > 0:
+                    for rdata_name in rdata_list:
+                        
+                        #see if rdata_name is in kwargs
+                        if rdata_name in arg_dict.keys():
+                            post_data['rdata'][rdata_name] = arg_dict[rdata_name]
+
+            # if there are options, set them in the data dictionary as well
+
+            log.debug("Adding options to postargs")
+            if len(option_list) > 0:
+                for option_name in option_list:
+                    if option_name in arg_dict.keys():
+                        
+                        option = action_map['options'][option_name]
+
+                        # if constant value is set, use that
+                        if 'constant' in option.keys():
+                            post_data[option_name] = option['constant']
+                        elif option_name in arg_dict.keys():
+                            post_data[option_name] = arg_dict[option_name]
+                            
+        if self.logged_in is False:
+            self.login()
+            
+        #remove trailing ? from uri if it exists
+        request_uri = re.sub('\?$','',request_uri)
+        log.info('Request URL: {0}'.format(request_uri))
+        log.debug('Postdata: {0}'.format(pformat(post_data)))
+                            
+        result = self.execute(request_uri, method, post_data)
+        log.debug('Data received: \n{0}'.format(pformat(result)))
+        
+        if (method != 'GET') and (auto_publish is True) and (resource != 'ZoneNoteReport'):
+            log.debug('Autopubish criteria met')
+            self._job_status(result['job_id'])
+            self._auto_publish(arg_dict['zone'])
+            
+        return result
diff --git a/DynResource/formatter.py b/DynResource/formatter.py
new file mode 100644
index 0000000..44a1144
--- /dev/null
+++ b/DynResource/formatter.py
@@ -0,0 +1,256 @@
+import logging
+import re
+from pprint import pformat
+
+
+#if logger name is specified, log commands will log to it
+class Formatter(object):
+    
+    def __init__(self,logger=None):
+        
+        global log
+        if logger is not None:
+            parent_logger = logger
+            log = logging.getLogger('{0}.{1}'.format(parent_logger,__name__))
+        #if not, set up a NullHandler so log commands don't error
+        else:
+            log = logging.getLogger('{0}'.format(__name__))
+            null_handler = logging.NullHandler()
+            log.addHandler(null_handler)
+
+    def _leading_spaces(self,level, step=4):
+        space = ''
+        level_counter = level * step
+        while level_counter > 0:
+            space = " {0}".format(space)
+            level_counter = level_counter-1
+            
+        return space
+    
+    def standard(self,result, output=[], level=0, last_key=None, last_type=None):
+        log.debug('Starting output_formatter loop')
+        
+        if isinstance(result, dict):
+            log.debug('Dictionary instance detected')
+            if result and (last_type == 'dict'):
+                line = "{0}{1}:".format(self._leading_spaces(level),last_key)
+                output.append(line)
+                log.debug("Dictionary detected inside of Dictionary")
+                log.debug('Current level: {0}'.format(level))
+                level = level+1
+    
+            for key in result.keys():
+                output = self.standard(result[key], output, level, key, 'dict')
+                
+        elif isinstance(result, list):
+            log.debug('List instance detected')
+            
+            if result: 
+                if last_type == 'dict':
+                    line = "{0}{1}:".format(self._leading_spaces(level),last_key)
+                    log.debug("Dictionary detected inside of List")
+                    output.append(line)
+                    level = level+1
+    
+                divider_line = "----------------"
+                level_counter = level
+                while level_counter > 0:
+                    divider_line = "    {0}".format(divider_line)
+                    level_counter = level_counter-1
+        
+                for item in result:
+                    output.append(divider_line)
+                    output = self.standard(item, output, level, None, 'list')
+                    
+                output.append(divider_line)
+        
+        else:
+            log.debug('String detected')
+            
+            if last_type == 'dict':
+                line = "{0}{1}: {2}".format(self._leading_spaces(level),last_key, result)
+                output.append(line)
+            elif last_type == 'list':
+                line = "{0}{1}".format(self._leading_spaces(level),result)
+                output.append(line)
+            else:
+                line = "{0}{1}".format(self._leading_spaces(level),result)
+                output.append(line)
+                
+            #log.debug(pformat(output))
+        
+        return output
+        
+
+    def _flatten_headers(self, results, headers=[], parent=None):
+        
+        log.debug('Flattening headers')
+        log.debug('Current data: {0}'.format(results))
+        
+        if parent is None:
+            log.debug('Parent is None')
+            if isinstance(results, dict):
+                log.debug('Data is a dictionary')
+                for key in results.keys():
+                    log.debug('Recursing key {0}'.format(key))
+                    log.debug('headers gathered: {0}'.format(headers))
+                    headers = self._flatten_headers(results[key], headers, key)
+            elif isinstance(results, list):
+                log.debug('Data is a list')
+                for item in results:
+                    log.debug('Recusing List')
+                    log.debug('headers gathered: {0}'.format(headers))
+                    headers = self._flatten_headers(item, headers, None)
+        else:
+            log.debug('Parent is {0}'.format(parent))
+            if isinstance(results, dict):
+                log.debug('Data is a dictionary')
+                for key in results.keys():
+                    log.debug('Recursing key {0}'.format(key))
+                    log.debug('headers gathered: {0}'.format(headers))
+                    headers = self._flatten_headers(results[key], headers, key)
+            elif isinstance(results, list):
+                for item in results:
+                    headers = self._flatten_headers(item, headers, None)
+            else:
+                log.debug('String detected: {0}'.format(parent))
+                headers.append("{0}".format(parent))
+        
+        return headers
+    
+    def _collect_records(self, results, records=[], parent=None):
+        
+        log.debug('Collecting records from results')
+        
+        if parent is None:
+            log.debug('Parent is None')
+            if isinstance(results, dict):
+                log.debug('Data is a dictionary')
+                for key in results.keys():
+                    log.debug('Recursing key {0}'.format(key))
+                    log.debug('{0} records collected'.format(len(records)))
+                    records = self._collect_records(results[key], records, key)
+            elif isinstance(results, list):
+                for item in results:
+                    log.debug('{0} records collected'.format(len(records)))
+                    records = self._collect_records(item, records, None)
+        else:
+            log.debug('Parent is {0}'.format(parent))
+            if isinstance(results, dict):
+                log.debug('Data is a dictionary')
+                for key in results.keys():
+                    log.debug('Recursing key {0}'.format(key))
+                    log.debug('{0} records collected'.format(len(records)))
+                    records = self._collect_records(results[key], records, key)
+            elif isinstance(results, list):
+                log.debug('List detected')
+                for item in results:
+                    log.debug('{0} records collected'.format(len(records)))
+                    records.append(item)
+                
+        return records
+        
+    def _quote_data(self, value, delimiter):
+        
+        if isinstance(value, unicode):
+            log.debug("String instance detected for value, testing for quoting")
+            log.debug(value)
+            quote = '\"'
+            if re.search('\"', "{0}".format(value)):
+                log.debug("double quotes found, switching to single quotes")
+                quote = "\'"
+            
+            #quote spaces no matter what
+            if re.search(' ', "{0}".format(value)):
+                log.debug("Space detected in value, quoting")
+                value = "{0}{1}{0}".format(quote,value)
+            
+            elif delimiter == ",":
+                log.debug("Delimiter is a comma")
+                if re.search(",", "{0}".format(value)):
+                    log.debug("Comma detected in value, quoting")
+                    value = """{0}{1}{0}""".format(quote,value)
+        else:
+            output = value
+                    
+        return value
+    
+    def csv(self, results, arg_dict, delimiter=','):
+        log.debug('CSV printing format detected')
+        
+        if 'datafields' in arg_dict.keys():
+            log.debug("datafields set at command prompt")
+            header_set = set(arg_dict['datafields'])
+        else:
+            log.debug("datafields not specified")
+            all_headers = []
+            for zone in results.keys():
+                headers = self._flatten_headers(results[zone]['data'])
+                all_headers.extend(headers)
+                
+            header_set = set(all_headers)
+            log.info('No datafields specified.  Using all')
+        
+        output = []
+        
+        if 'noheaders' in arg_dict.keys():
+            if arg_dict['noheaders'] is not True:
+                log.info('Noheaders option not detected')
+                line = ''
+                
+                for header in header_set:
+                    if line == '':
+                        line = "{0}".format(header)
+                    else:
+                        line = "{0}{1}{2}".format(line, delimiter, header)
+                output.append(line)
+        
+        records = []
+        for zone in results.keys():
+            log.debug('Collecting records for {0}'.format(zone))
+            records.extend(self._collect_records(results[zone]['data']))
+        
+        for record in records:
+            line = ''
+            for header in header_set:
+                value = ''
+                for field in record.keys():
+                    if isinstance(record[field], dict):
+                        log.debug("Field is a dictionary")
+                        for subfield in record[field].keys():
+                            if header == subfield:
+                                log.debug('Header {0} found in subfield {1}'.format(header, subfield))
+                                value = self._quote_data(record[field][subfield], delimiter)
+                            else:
+                                log.debug('Header {0} not found in subfield {1}'.format(header, subfield))
+                    else:
+                        if header == field:
+                            log.debug('Header {0} found in field {1}'.format(header, field))
+                            value = self._quote_data(record[header], delimiter)
+                        else:
+                            log.debug('Header {0} not found in field {1}'.format(header, field))
+                
+                if line == '':
+                    line = "{0}".format(value)
+                else:
+                    line = "{0}{1}{2}".format(line, delimiter, value)
+                        
+            output.append(line)
+                
+        return output
+        
+    def as_list(self, results, arg_dict):
+        log.debug('as-list function has been activated')
+        output = self.csv(results, arg_dict, ' ')
+        
+        return output
+        
+    def zones_as_list(self, results, arg_dict):
+        
+        log.debug('Getting list of zones')
+        zones = []
+        
+        for zonelink in results['data']:
+            zones.append(zonelink.rsplit('/')[-2])
+            
+        return zones
diff --git a/README.md b/README.md
index c90bf76..8d3b726 100644
--- a/README.md
+++ b/README.md
@@ -1,128 +1,167 @@
-# Dyn DNS cli tool
-### Usage
-```
-usage: dyncli [-h] [-e ENDPOINT] [-c CREATE] [--cname] [-v VALUE] [-t TTL]
-              [-d DELETE] [-u UPDATE_RECORD] [-U USER] [-P PASSWORD]
-              [-A ACCOUNT] [-Z ZONE] [-l] [--verbose]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -e ENDPOINT, --endpoint ENDPOINT
-                        The endpoint to make API requests.
-  -c CREATE, --create CREATE
-                        Create a new record. Defaults to A record unless
-                        --cname is set.
-  --cname               Create a cname record instead of an A record.
-  -v VALUE, --value VALUE
-                        The value to set the DNS record to. Eg 10.0.0.101.
-  -t TTL, --ttl TTL     TTL of record in seconds.
-  -d DELETE, --delete DELETE
-                        Delete an existing record
-  -u UPDATE_RECORD, --update UPDATE_RECORD
-                        Perform a DNS update on an existing record.
-  -U USER, --user USER  The username to connect to the dyn api. Can also be
-                        set as DYN_USER in environment.
-  -P PASSWORD, --password PASSWORD
-                        The password to use with the dyn api. Can also be set
-                        as DYN_PW in environment.
-  -A ACCOUNT, --account ACCOUNT
-                        The account name used to make API requests. Can be set
-                        as DYN_ACCOUNT in environment.
-  -Z ZONE, --zone ZONE  The zone to take action on. Eg example.com. Can be set
-                        as DYN_ZONE in environment.
-  -l, --list            List all dns records as a csv file.
-  --verbose             Print out api responses.
-```
-
-Dyn is a nice DNS service. It's an alternative to Amazon's Route 53. Though I do not believe that dyn's API is as robust as amazone, with the right set of tools is just dandy.
-
-This tool allows for the manipulation of DNS records via the restful API.
-
-It currently supports the following:
-* Create A and CNAME records
-* Update A and CNAME records
-* Delete A and CNAME records
-* List all of the records as a CSV
-
-### Requirements
-The requests & argparse packages are required but not currently part of the standard library. Get them with pip: 
-```
-pip install -r requirements.txt
-```
-
-You can pass your username and password directly into the script, but it's better if you setup a few environment variables. dyncli will take advantage of the following environment variables if they are present:
-```
-DYN_USER
-DYN_PW
-DYN_ZONE
-DYN_ACCOUNT
-```
-
-You can activate these by appending them to your ```~/.bash_profile```:
-```
-export DYN_USER='foo'
-export DYN_PW='bar'
-export DYN_ZONE='example.com'
-export DYN_ACCOUNT='example'
-```
-
-### Creating a record
-Right now both A and CNAME record creation is supported. Create a record uses the ```-c``` flag along with the optional ```--cname``` flag if that's your desired record type.
-
-The default record type is an address (A) record.
-```
-# Create an A record with default TTL
-$ ./dyncli -c myfqdn.example.net -v 10.0.0.100
-
-# Create an A record with custom TTL
-$ ./dyncli -c myfqdn.example.net -v 10.0.0.100 --ttl 3600
-
-# Create a CNAME record
-$ ./dyncli -c myfqdn.example.net -v otherfqdn.example.net --cname
-```
-
-### Updating a record
-Once records are created, they can be easily updated with the ```-u``` or ```--update``` flag.
-
-```
-# Update the TTL of an existing record
-$ ./dyncli -u myfqdn.example.net --ttl 3600
-
-# Update the value of an existing cname record
-$ ./dyncli -u myfqdn.example.net -v someotherfqdn.example.net
-```
-
-## Deleting a record
-Records are deleted by passing the ```-d``` or ```--delete``` flag.
-```
-# Delete an address (A) record
-$ ./dyncli -d myfqdn.example.net
-
-# Delete a cname record (requires the --cname flag)
-$ ./dyncli -d myfqdn.example.net --cname
-```
-
-### List all records (csv format)
-Sometimes it's useful to list all of the records. We use this to do a simple nightly backup of our DNS zone.
-
-The output format is a simple CSV file. Beware that if you have commas in your TXT record, they'll be translated to a pipe (```|```).
-```
-$ ./dyncli --list
-zone,ttl,fqdn,record_type,data
-example.net,300,test.example.net,CNAME,test2.example.net
-example.net,300,foo.example.net,A,172,16.0.100
-example.net,3600,example.net,TXT,public_key=sdjflksdj
-..
-```
-
-Sometimes it's also useful to check if a zone exists before you go creating one willy nilly
-```
-$ ./dyncli --list | grep database
-example.net,300,database.example.net,A,172.16.0.100
-example.net,300,database.internal.example.net,A,172.16.0.100
-example.net,300,database.something.example.net,A,172.16.0.100
-
-(See what happens when you go on creating records without checking first?)
-```
-
-If you notice any bugs please open an issue.
+#DynCLI
+
+DynCLI is a command line client written in Python for making changes to your Managed DNS account via DynectAPI.
+The included DynResource module is used by DynCLI as an abstraction layer from the rather stark DynAPI client.
+
+As part of installation, a virtualenv must be built on Python 2.7.  Run the install.sh script to build the virtualenv,
+PIP in requirements, and add environment variables and shortcuts for ease of use.
+
+##Developers Notes
+
+The structure of the application is based around the DynRestResource and DynHelper modules.  
+
+1. DynRestResource - This class is used to make a single API call to the DynectAPI.
+2. DynHelper - This class is a base class for other helper modules included.
+        
+The use of dynresourcemap.py is two fold in order to keep things consistent and extensible.  DynRestResource class uses 
+it to load the mapped-out options for the specified DynectAPI resource, which means that DynHelper uses this in aggregate.
+The other place where dynresourcempa.py is important is in argument parsing in dyncli.py.  The argparse module builds out
+contextual options based on the resource spec in the file.   In other words, by adding a Dynect API Resource in dynresourcemap.py,
+you are using the same config for both creating the argument parsing and the actual parameters for the DynResource to use.
+No change in code (should be) required to add a Dynect API resource to the library and the dyncli.py script.
+
+##dyncli usage
+
+dyncli utilizes argparse to provide contextual help at the command line.  By using the -h flag you can see further options
+from your current arguments:
+
+    $ dyncli -h
+    usage: dyncli.py [-h] [-U USER] [-A ACCOUNT]
+                     [-L {CRITICAL,ERROR,WARNING,INFO,DEBUG}]
+                     {search,delete,add,update,resource}...
+
+    positional arguments:
+      {search,delete,add,update,resource}
+        search              Search Dyn Data
+        delete              Delete stuff
+        add                 Add stuff
+        update              Update stuff
+        resource            Make direct API Calls
+    
+    optional arguments:
+      -h, --help            show this help message and exit
+      -U USER, --user USER  The username to connect to the dyn api. Can also be
+                            set as DYN_USER in environment or in settings.py.
+      -A ACCOUNT, --account ACCOUNT
+                            The account name used to make API requests. Can be set
+                            as DYN_ACCOUNT in environment or in settings.py.
+      -L {CRITICAL,ERROR,WARNING,INFO,DEBUG}, --loglevel {CRITICAL,ERROR,WARNING,INFO,DEBUG}
+                            Logging output level
+
+In the above help, we can see that our command first positional(required) argument is one of the ones in brackets
+
+    positional arguments:
+      {search,delete,add,update,resource}
+        search              Search Dyn Data
+        delete              Delete stuff
+        add                 Add stuff
+        update              Update stuff
+        resource            Make direct API Calls
+
+All of the above options are self-explanitory actions, except for 'resource' which maps to a single DynectAPI Resource as 
+found in the documentation (https://help.dyn.com/rest-resources/)
+The ones in that list are the ones we have already mapped out in dynresourcemap.py.  Adding more resources later only requires an
+addition to that file, not to dyncli.py.  They populate dynamically.
+
+There are also some optional arguments in the first section above in capital letter flags.  If you have configured your etc/settings.py
+properly, you should not need to use these flags.
+
+###Simple Resource-specific Commands
+
+Next, lets say we are going to use the ARecord resource.  The contextual help at the next level looks like this:
+
+    $ dyncli resource ARecord -h
+    usage: dyncli.py resource ARecord [-h] {add,delete,list,update,get} ...
+    
+    positional arguments:
+      {add,delete,list,update,get}
+        add                 Add ARecord to a zone
+        delete              Delete ARecord from a zone
+        list                List ARecord that match in a zone
+        update              Update an A record
+        get                 Get a specific ARecord from a zone
+    
+    optional arguments:
+      -h, --help            show this help message and exit
+
+
+Our next required argument is the action we would like to perform with the resource.  In this case, let us say we want to add an ARecord:
+
+    $ dyncli resource ARecord add -h
+    usage: dyncli.py resource ARecord add [-h] [-a ADDRESS] [-t [TTL]] zone fqdn
+    
+    positional arguments:
+      zone
+      fqdn
+    
+    optional arguments:
+      -h, --help            show this help message and exit
+      -a ADDRESS, --address ADDRESS
+                            IPv4 Address
+      -t [TTL], --ttl [TTL]
+                            IPv4 Address
+
+At this point we appear to be at the nitty gritty of adding an ARecord.  We will have to provide the required arguments of the zone
+that the new ARecord will be added to, and the fqdn of the new record.  We then use the -a and -t options to set the IP Address
+and the TTL.  Address is required (by the api, not yet required in argparse), but TTL is optional.
+
+###Aggregate Commands / Helpers
+Aggregate Commands based on the action that the user wishes to perform.  Most day to day tasks would require many resource/single
+command calls to accomplish, so CLI users and bash scripters will use these commands.
+Unlike single resource-based calls, these commands require an actual function in lib/DynAPIHelpers.py DynHelper class in order to carry out
+specific tasks.  
+
+The current helpers are based on CRUD standards - search, add, update, and delete.  They behave much like the resource commands:
+
+    $ dyncli search -h
+    usage: dyncli.py search [-h] {zones,records,services,changelog} ...
+
+    positional arguments:
+      {zones,records,services,changelog}
+        zones               Search Dyn Data
+        records             Search Dyn Data
+        services            Search Dyn Data
+        changelog           Search Dyn Data
+    
+    optional arguments:
+      -h, --help            show this help message and exit
+
+and the submenu for the records option:
+
+    $ dyncli search records -h
+    usage: dyncli.py search records [-h] [-z [ZONES [ZONES ...]]]
+                                    [-r [RECORD_TYPES [RECORD_TYPES ...]]]
+                                    [--as_list] [-m TTL_MIN] [-M TTL_MAX] [--csv]
+                                    [--noheaders]
+                                    [-D [DATAFIELDS [DATAFIELDS ...]]]
+                                    
+    optional arguments:
+      -h, --help            show this help message and exit
+      -z [ZONES [ZONES ...]], --zones [ZONES [ZONES ...]]
+                            Zones to search
+      -r [RECORD_TYPES [RECORD_TYPES ...]], --record_types [RECORD_TYPES [RECORD_TYPES ...]]
+                            Record types
+      --as_list             Display data as a Bash-style list, space separated if
+                            multiple datafields are requested.
+      -m TTL_MIN, --ttl_min TTL_MIN
+                            Minimum TTL to search for
+      -M TTL_MAX, --ttl_max TTL_MAX
+                            Maximum TTL to search for
+      --csv                 Output as CSV
+      --noheaders           Do not show headers at top of CSV
+      -D [DATAFIELDS [DATAFIELDS ...]], --datafields [DATAFIELDS [DATAFIELDS
+
+You many notice that there is a combination of short and long flag types, as well as position arguments.  The logic currently
+behind this is very uniform with Resource commands, and rather uniform with Helpers as follows:
+
+1. Positional arguments are used for the major parts of the command, including the FQDN of a record in question.
+2. Short flags represent GET or POST style parameters for the requests.  Some are required, some are not.
+3. Long flags present True/False type options that have no trailing data.  Their data is always a constant.
+
+NOTE:  Right now we do not have strict enough requirements/exclusive(and/or) argument checking, so the API will just kick back
+an error if you have used the resource incorrectly.  This will be upgraded in later versions.
+
+##TO DO
+1. Add better argument checking, including required and/or mutually exclusive options.
+2. Add more DynectAPI resource mappings
+3. Add a unit test facility, hopefully leveraging the DynAPIMap to make tests with parameters only.
\ No newline at end of file
diff --git a/dyncli b/dyncli
index 940a3e6..19f5c08 100755
--- a/dyncli
+++ b/dyncli
@@ -1,314 +1,5 @@
-#!/usr/bin/env python
-import json
-import argparse
-import requests
-from os import environ
-from sys import exit
+#!/bin/bash
 
-parser = argparse.ArgumentParser()
-parser.add_argument('-e','--endpoint',dest='endpoint',default='https://api2.dynect.net/REST/',
-  help='The endpoint to make API requests.')
-parser.add_argument('-c','--create',dest='create',
-  help='Create a new record. Defaults to A record unless --cname is set.')
-parser.add_argument('--cname',dest='cname',action='store_true',
-  help='Create a cname record instead of an A record.')
-parser.add_argument('-v','--value',dest='value',
-  help='The value to set the DNS record to. Eg 10.0.0.101.')
-parser.add_argument('-t','--ttl',dest='ttl',type=int,default=300,
-  help='TTL of record in seconds.')
-parser.add_argument('-d','--delete',dest='delete',
-  help='Delete an existing record')
-parser.add_argument('-u','--update',dest='update_record',
-  help='Perform a DNS update on an existing record.')
-parser.add_argument('-U','--user',dest='user',
-  help='The username to connect to the dyn api. Can also be set as DYN_USER in environment.')
-parser.add_argument('-P','--password',dest='password',
-  help='The password to use with the dyn api. Can also be set as DYN_PW in environment.')
-parser.add_argument('-A','--account',dest='account',
-  help='The account name used to make API requests. Can be set as DYN_ACCOUNT in environment.')
-parser.add_argument('-Z','--zone',dest='zone',
-  help='The zone to take action on. Eg example.com. Can be set as DYN_ZONE in environment.')
-parser.add_argument('-l','--list',dest='list',action='store_true',
-  help='List all dns records as a csv file.')
-parser.add_argument('--verbose',dest='verbose',action='store_true',
-  help='Print out api responses.')
-args = parser.parse_args()
+: ${DT_ROOT}?"No DT_ROOT user environment variable set.  Please run install.sh first"}
 
-config = {}
-config['endpoint'] = args.endpoint
-config['zone'] = args.zone
-config['create'] = args.create
-config['cname'] = args.cname
-config['value'] = args.value
-config['ttl'] = args.ttl
-config['delete'] = args.delete
-config['update_record'] = args.update_record
-config['user'] = args.user
-config['password'] = args.password
-config['account'] = args.account
-config['list'] = args.list
-config['verbose'] = args.verbose
-
-def error(msg,exit_code=1):
-  '''
-  Helper function for printing errors and exiting. Default exit code is 1.
-  '''
-  print("Error: %s" % msg)
-  exit(exit_code)
-
-def verify_credentials():
-  '''
-  In order to make requests to the DYN api we need 4 pieces of auth info:
-    1. -U/--user or env['DYN_USER']
-    2. -P/--PASSWORD or env['DYN_PW']
-    3. -A/--account or env['DYN_ACCOUNT']
-    4. -Z/--zone or env['DYN_ZONE']
-
-  Check for the existence of these either as command line arguments or
-  environment variables. Command line arguments take precedence over ENV if
-  both are present.
-  '''
-  def test_env(local_var,env_var):
-    if not config[local_var]:
-      try:
-        config[local_var] = environ[env_var]
-      except KeyError:
-        error("%s not set on cmdline and %s not present in local environment"
-          % (local_var,env_var))
-
-  test_env('user','DYN_USER')
-  test_env('password','DYN_PW')
-  test_env('account','DYN_ACCOUNT')
-  test_env('zone','DYN_ZONE')
-
-def call_dyn(suffix,method='get',data=None,detailed=False):
-  '''
-  Call the dyn api. Returns json object
-  '''
-  response = None
-  if data:
-    data = json.dumps(data)
-
-  url = config['endpoint'] + suffix
-  if detailed:
-    url = url + '?detail=y'
-
-  if config['verbose']:
-    print('Connecting to: ' + url)
-
-  header = {
-    'content-type': 'application/json',
-    'Accept': 'application/json'
-  }
-
-  if config.get('token'):
-    header['Auth-Token'] = config['token']
-
-  try:
-    response = getattr(requests, method)(url,headers=header,data=data)
-  except Exception, e:
-    error(e)
-
-  resp = json.loads(response.text)
-  if config['verbose']:
-    print json.dumps(resp,indent=2)
-
-  if resp['status'] != 'success':
-    error(resp['msgs'][0]['INFO'])
-
-  return resp
-
-def get_token(credentials):
-  '''
-  Authenticates with Dyn. Returns a session token string if successful.
-
-  Requires a dict with the following:
-    dict['account']
-    dict['user']
-    dict['password]'
-
-  '''
-  suffix = 'Session/'
-  data = {
-    'customer_name': credentials['account'],
-    'user_name': credentials['user'],
-    'password': credentials['password']
-  }
-
-  # Squelch this message if we're printing a CSV
-  if not config['list']:
-    print('Initializing session...')
-
-  resp = call_dyn(suffix,method='post',data=data)
-  return resp['data']['token']
-
-def list_records():
-  '''
-  Print all the records associated with a zone in a CSV format. Useful for
-  backing up a zone.
-  '''
-  suffix = 'AllRecord/%s/' % config['zone']
-  data = call_dyn(suffix,detailed=True)
-  records = []
-
-  # Print the initial CSV header
-  record_format = ['zone','ttl','fqdn','record_type','data']
-  records.append(','.join(record_format))
-
-  # Iterate over all of the DNS types
-  for dns_types in data['data'].values():
-    for dns_entry in dns_types:
-
-      # Dyn returns data in a strange format. Here we first try and grab the
-      # record data based on the record_type. If that fails we'll dump the data
-      # from dyn but transcribe the commas to pipes so it doesn't affect our
-      # formatting
-      address_data = None
-
-      if dns_entry['record_type'] == 'A':
-        address_data = dns_entry['rdata']['address']
-      elif dns_entry['record_type'] == 'CNAME':
-        address_data = dns_entry['rdata']['cname']
-      elif dns_entry['record_type'] == 'NS':
-        address_data = dns_entry['rdata']['nsdname']
-      elif dns_entry['record_type'] == 'TXT':
-        address_data = dns_entry['rdata']['txtdata']
-      else:
-        # Something funky
-        strange_format = []
-        for key, value in dns_entry['rdata'].iteritems():
-          formatted_entry = key + ':' + str(value)
-          strange_format.append(formatted_entry)
-        address_data = '|'.join(strange_format)
-
-      record = ','.join([
-        dns_entry['zone'],
-        str(dns_entry['ttl']),
-        dns_entry['fqdn'],
-        dns_entry['record_type'],
-        str(address_data),
-      ])
-      records.append(record)
-
-  return records
-   
-def publish(zone):
-  '''
-  Publish changes we've made to dyn. No going back from here.
-  '''
-  data = {
-    'publish': 1
-  }
-  print zone
-  suffix = 'Zone/%s/' % zone
-  print('Attempting to publish zone...')
-  call_dyn(suffix,method='put',data=data)
- 
-def create_record(address):
-  '''
-  Create a record. First argument is a dict with dict['address'],
-  dict['value'], and optionally dict['ttl'].
-  '''
-  payload = {
-    'rdata': {},
-    'ttl': address['ttl']
-  }
-
-  if address['value'] == 'None':
-    error('Missing parameter -v/--value.')
-
-  if address['cname']:
-    payload['rdata']['cname'] = address['value']
-    suffix = "CNAMERecord/%s/%s/" % (address['zone'], address['create'])
-  else:
-    payload['rdata']['address'] = address['value']
-    suffix = "ARecord/%s/%s/" % (address['zone'], address['create'])
-
-  print('Attempting to create record...')
-  call_dyn(suffix,method='post',data=payload)
-  publish(config['zone'])
-
-def update_record(address):
-  '''
-  Update an existing record. Accepts dict with 'update_record' and either
-  'value' or 'ttl' or both.
-  '''
-  suffix = "ARecord/%s/%s/" % (address['zone'], address['update_record'])
-  payload = {
-    'rdata': {}
-  }
-
-  if address.get('value'):
-    payload['rdata'] = {
-      'address': address['value']
-    }
-
-  if address.get('ttl'):
-    payload['ttl'] = address['ttl']
-
-  print('Attempting to update record...')
-  resp = call_dyn(suffix,method='put',data=payload)
-  if resp['msgs'][0]['INFO'] == 'id: You did not reference a specific record':
-    error('Unable to update record. Check spelling or try --cname?')
-  publish(config['zone'])
-
-def delete_record(address):
-  '''
-  Delete a record. Requires a dict that with dict['delete'] and dict['value'].
-  Optionally is dict['cname'] (True/None) if the record is a cname.
-
-  Be very careful and ensure this is what you want to do.
-  '''
-  if not address['delete']:
-    error('Missing first argument.')
-
-  if address['cname']:
-    suffix = "CNAMERecord/%s/%s/" % (address['zone'], address['delete'])
-  else:
-    suffix = "ARecord/%s/%s/" % (address['zone'], address['delete'])
-
-  print("Attempting to delete record: %s" % address['delete'])
-  resp = call_dyn(suffix,method='delete')
-
-  print resp['msgs'][0]['INFO']
-  if resp['msgs'][0]['INFO'] == 'delete: 0 records deleted':
-    if not address['cname']:
-      error('No records deleted. Check spelling or try toggling --cname?')
-
-  publish(config['zone'])
-
-def end_session(token):
-  '''
-  Delete the existing session. Requires a token. This prevents further changes
-  from being made with the created session token.
-  '''
-  suffix = 'Session/'
-
-  # Squelch these lines if we are printing a CSV format
-  if not config['list']:
-    print('Ending current session...')
-
-  call_dyn(suffix,method='delete')
-  exit()
-
-if __name__ == '__main__':
-  verify_credentials()
-  config['token'] = get_token(config)
-
-  if config['list']:
-    for record in list_records():
-      print record
-
-  elif config['create']:
-    create_record(config)
-
-  elif config['update_record']:
-    update_record(config)
-
-  elif config['delete']:
-    delete_record(config)
-
-  else:
-    error('No arguments provided.')
-
-  end_session(config['token'])
+$DT_ROOT/env/bin/python $DT_ROOT/dyncli.py "$@"
\ No newline at end of file
diff --git a/dyncli.py b/dyncli.py
new file mode 100755
index 0000000..103e979
--- /dev/null
+++ b/dyncli.py
@@ -0,0 +1,355 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import argparse
+import os
+import sys
+from pprint import pprint, pformat
+import getpass
+import logging
+from logging import handlers
+
+from settings import *
+from DynResource import DYN_API_MAP, DynRestResource, dynhelpers, Formatter
+
+
+def set_credentials():
+
+    # decide whether to use credentials from in this order:
+    #   1. the command line arguments
+    #   2. the settings.py file
+    #   3. DYN_USER,DYN_PASSWORD,DYN_ACCOUNT from Environment
+
+    if args.user is not None:
+        log.debug('No User specified at command prompt, trying settings.py'
+                  )
+        user = args.user
+        log.debug('User specified at prompt, prompting for password')
+        password = getpass.getpass(prompt='DynAPI Password:')
+    else:
+        try:
+            user = USER
+            log.debug('User {0} found in settings.py'.format(user))
+        except:
+            try:
+                log.debug('settings.py did not contain username, trying environment'
+                          )
+                user = os.environ['DYN_USER']
+                log.debug('User {0} found in environment'.format(user))
+            except:
+                log.error('User name not specified at prompt, settings.py, or environment'
+                          )
+                raise
+        try:
+            password = PASSWORD
+            log.debug('Password found in settings.py')
+        except:
+            try:
+                log.debug('settings.py did not contain a password, trying environment'
+                          )
+                password = os.environ['DYN_PASSWORD']
+                log.debug('Password found in environment')
+            except:
+                log.error('Password not found in settings.py or environment'
+                          )
+                raise
+
+    if args.account is not None:
+        account = args.account
+        log.debug('Account name {0} specified in command'.format(account))
+    else:
+        try:
+            account = ACCOUNT
+            log.debug('Account name {0} found in settings.py'.format(account))
+        except:
+            try:
+                log.debug('Account name not found in settings.py.  Checking environment'
+                          )
+                account = os.environ['DYN_ACCOUNT']
+                log.debug('Account name {0} found in environment'.format(account))
+            except:
+                log.error('Account name not specified in command, settings.py, or environment'
+                          )
+                raise
+    log.info('executed as user {0}'.format(user))
+
+    return [user, password, account]
+
+
+def convert_args_to_dict():
+
+    # argparse keeps the arguments as attributes of an object.
+    # The library accepts a dictionary of keyword args
+    #   in order to preserve its independence
+
+    log.debug('Converting args to dictionary')
+    arg_dict = {}
+
+    attr_list = args.__dict__.keys()
+    for attribute in attr_list:
+
+        # important to filter out Boolean flags that were not set
+
+        if getattr(args, attribute) is not None:
+            if attribute != 'password':
+                log.debug('Attribute {0} found, value {1}'.format(attribute,
+                          getattr(args, attribute)))
+            if attribute == 'helper_action':
+                arg_dict['resource'] = getattr(args, attribute)
+            arg_dict[attribute] = getattr(args,attribute)
+        else:
+            log.debug('Attribute {0} was not set'.format(attribute))
+
+    return arg_dict
+
+
+def _get_option_item_parser(option_name,option_item):
+
+    option_item_parser = []
+    option_item_kwargs = {}
+    
+    #order of the argparse argument args matters
+    #short flag
+    if 'flag' not in option_item.keys():
+        option_item['flag'] = False
+        
+    if option_item['flag'] is False:
+        # if the option flag is set to False, set the default to false and
+        #  store true if it appears
+        #  These are for Boolean flags that don't require input
+        option_item_kwargs['action'] = 'store_true'
+        option_item_kwargs['default'] = 'store_false'
+        option_item_parser.append("--{0}".format(option_name))
+    elif isinstance(option_item['flag'], str):
+        option_item_parser.append("-{0}".format(option_item['flag']))
+        option_item_parser.append("--{0}".format(option_name))
+        
+    #if the flag was not False and not a string, it is positional and dest will take care of it.
+    
+    #build kwargs
+    if 'nargs' in option_item.keys():
+        option_item_kwargs['nargs'] = option_item['nargs']
+    if 'help' in option_item.keys():
+        option_item_kwargs['help'] = option_item['help']
+    option_item_kwargs['dest'] = option_name
+    
+    output = {
+        'args': option_item_parser,
+        'kwargs': option_item_kwargs,
+    }
+    
+    return output
+    
+
+def main():
+
+    log.info('Begin dyncli script execution')
+
+    # set credentials
+
+    try:
+        [args.user, args.password, args.account] = set_credentials()
+        log.debug('Credentials set successfully')
+    except Exception, e:
+        log.exception('Script failed to set credentials, exiting')
+        log.debug(e)
+        sys.exit(1)
+
+    # convert args to dictionary
+
+    try:
+        arg_dict = convert_args_to_dict()
+        log.debug('Successfully converted args to dictionary for consumption'
+                  )
+    except Exception, e:
+        log.exception("""Script failed to convert arguments provided
+            into a dictionary for consumption, exiting"""
+                      )
+        log.debug(e)
+        sys.exit(1)
+
+    # create the api object and provide the argument dictionary
+
+    try:
+        if args.helper == 'resource':
+            resource_obj = DynRestResource(args.user, args.password, args.account, logger='dyncli')
+            log.debug('Successfully created Dynect resource object')
+            result = resource_obj.do(args.resource,args.action,arg_dict)
+            log.debug('Successfully retrieved result set')
+            pprint(result)
+        else:
+            
+            #for helpers, action and resource args are reversed.  May fix later
+            if args.helper == 'add':
+                helper_obj = dynhelpers.Add(args.user, args.password, args.account, logger='dyncli')
+            elif args.helper == 'update':
+                helper_obj = dynhelpers.Update(args.user, args.password, args.account, logger='dyncli')
+            elif args.helper == 'delete':
+                helper_obj = dynhelpers.Delete(args.user, args.password, args.account, logger='dyncli')
+            elif args.helper == 'search':
+                helper_obj = dynhelpers.Search(args.user, args.password, args.account, logger='dyncli')
+                
+            log.debug('Successfully created Dyn Helper object')
+            result = helper_obj.do(args.helper_action, arg_dict)
+            log.debug('Successfully retrieved result set')
+            
+            output = Formatter(logger='dyncli')
+            
+            try:
+                if arg_dict['csv'] is True:
+                    for line in output.csv(result, arg_dict):
+                        print line
+                else:
+                    raise KeyError
+            except KeyError:
+                try:
+                    if arg_dict['as_list'] is True:
+                        if arg_dict['helper_action'] == 'zones':
+                            for line in output.zones_as_list(result,arg_dict):
+                                print line
+                        else:
+                            for line in output.as_list(result, arg_dict):
+                                print line
+                    else:
+                        raise KeyError
+                except KeyError:
+                    for line in output.standard(result):
+                        print line
+            
+    except Exception:
+
+        log.exception('Error while retrieving data from API, exiting')
+        sys.exit(1)
+
+    log.info('Dyncli script run completed successfully')
+
+
+if __name__ == '__main__':
+    parser = {}
+    subparser = {}
+
+    # main parser - these args are global and static.  Uppercase short flags,
+    #  and represent global parameters
+
+    parser['main'] = argparse.ArgumentParser()
+    parser['main'].add_argument('-U', '--user', dest='user',
+                                help="""The username to connect to the dyn api.
+                Can also be set as DYN_USER in
+                environment or in settings.py.""")
+    parser['main'].add_argument('-A', '--account', dest='account',
+                                help="""The account name used to make API requests. Can be set as
+                DYN_ACCOUNT in environment or in settings.py."""
+                                )
+    parser['main'].add_argument('-L', '--loglevel', choices=['CRITICAL'
+                                , 'ERROR', 'WARNING', 'INFO', 'DEBUG'],
+                                default='INFO',
+                                help='Logging output level')
+                                
+    # Declare the HELPER subparser
+
+    subparser['main'] = parser['main'].add_subparsers(dest='helper')
+    helpers = dynhelpers.dynhelpermap.DYN_HELPERS
+
+    for helper_key in helpers.keys():
+        
+        helper = helpers[helper_key]
+        parser[helper_key] = subparser['main'].add_parser(helper_key, help=helper['help'])
+
+        subparser[helper_key] = parser[helper_key].add_subparsers(dest='helper_action')
+
+        for action_key in helper['actions'].keys():
+            action = helpers[helper_key]['actions'][action_key]
+            helper_action = '{0}_{1}'.format(helper_key, action_key)
+            parser[action_key] = subparser[helper_key].add_parser(action_key, help=helper['help'])
+                    
+            # if options exist, decide what type of option they are, and build them out.
+            if 'options' in action.keys():
+                for option_name in action['options'].keys():
+                    option_item = action['options'][option_name]
+                    option_dict = _get_option_item_parser(option_name,option_item)
+                    parser[action_key].add_argument(*option_dict['args'],**option_dict['kwargs'])
+
+    # declare the RESOURCE subparser
+
+    parser['resource'] = subparser['main'].add_parser('resource',
+            help='Make direct API Calls')
+    subparser['resource'] = parser['resource'
+                                   ].add_subparsers(dest='resource',
+            help='Dynect API Resource Name')
+
+    # loop thru resources in the DynAPIMap dictionary and create a subparser for each
+
+    for resource in DYN_API_MAP.keys():
+        parser[resource] = subparser['resource'].add_parser(resource)
+        subparser[resource] = parser[resource].add_subparsers(dest='action')
+
+        action_map = DYN_API_MAP[resource]['actions']
+
+        # for each resource, loop thru the actions and build a subparser for each
+        for action in action_map.keys():
+            resource_action = '{0}_{1}'.format(resource, action)
+            url_vars = action_map[action]['url_vars']
+            method = action_map[action]['method']
+            parser[resource_action] = subparser[resource].add_parser(action, help=action_map[action]['help'])
+
+            # URL_VARS are positional with no flags - they are not optional
+
+            for url_var in url_vars:
+                if url_var in ['resource']:
+                    continue
+                parser[resource_action].add_argument(url_var)
+
+            # if rdata fields exist, build them out with long and short flags
+            if 'rdata' in action_map[action].keys():
+                for rdata_name in action_map[action]['rdata'].keys():
+                    rdata_item = action_map[action]['rdata'][rdata_name]
+                    rdata_option_dict = _get_option_item_parser(rdata_name,rdata_item)
+                    parser[resource_action].add_argument(*rdata_option_dict['args'],**rdata_option_dict['kwargs'])
+
+            # if options exist, decide what type of option they are, and build them out.
+            if 'options' in action_map[action].keys():
+                for option_name in action_map[action]['options'].keys():
+                    option_item = action_map[action]['options'][option_name]
+                    option_dict = _get_option_item_parser(option_name,option_item)
+                    parser[resource_action].add_argument(*option_dict['args'],**option_dict['kwargs'])
+
+
+    args = parser['main'].parse_args()
+
+    # set up logging
+
+    log_format = \
+        '%(name)s:%(lineno)d[%(process)d]: %(levelname)s - %(message)s'
+    log_level_numeric = getattr(logging, args.loglevel.upper())
+
+    try:
+        logging.captureWarnings(True)
+    except:
+        pass
+
+    logger_name = 'dyncli'
+    args.logger_name = logger_name
+    log = logging.getLogger(logger_name)
+    logformat = logging.Formatter(log_format)
+    log.setLevel(log_level_numeric)
+
+    # syslog handler
+
+    if SYSLOG_ENABLED == 1:
+        syslog_handler = \
+            logging.handlers.SysLogHandler(address=SYSLOG_ADDRESS)
+        syslog_handler.setFormatter(logformat)
+        log.addHandler(syslog_handler)
+    else:
+        null_handler = logging.NullHandler()
+        log.addHandler(null_handler)
+
+    # console handler
+
+    console_handler = logging.StreamHandler(stream=sys.stdout)
+    console_handler.setFormatter(logformat)
+    if args.loglevel.upper() != 'DEBUG':
+        console_handler.setLevel(log_level_numeric + 10)
+    log.addHandler(console_handler)
+
+    main()
diff --git a/install.sh b/install.sh
new file mode 100755
index 0000000..5f75b20
--- /dev/null
+++ b/install.sh
@@ -0,0 +1,107 @@
+#!/bin/bash
+
+die ()
+{
+    echo $1
+    exit 1
+}
+
+die_deactivate ()
+{
+    echo $1
+    deactivate
+    exit 1
+}
+
+interactive=1
+if [ $# > 0 ]
+then
+    if [ $1 == "-y" ]
+    then
+        interactive=0
+    fi
+fi
+
+printf 'Installing dns_tools application\n'
+
+ROOT_DIR=`pwd`
+
+# check if root
+if [ $EUID -ne 0 ]
+then
+    die "This script must be run as root"
+fi
+
+# create global shortcut
+printf "Checking for dyncli shortcut...."
+if [ -L /usr/local/bin/dyncli ]
+then
+    printf "Link already exists\n"
+else
+    ln -s $ROOT_DIR/dyncli /usr/local/bin/dyncli || die "\n\nError while setting up shortcut, exiting"
+fi
+
+# make virtualenv
+printf "Deleting previous virtualenv...:"
+rm -Rf env
+if [ $? == 0 ]
+then
+    printf "Done\n"
+else
+    printf "None Found"
+fi
+
+printf "Creating virtualenv...."
+virtualenv -p python2.7 env || die "\n\nError while setting up virualenv, exiting"
+printf "Done\n"
+
+# install pip dependencies
+printf "Installing Python requirements via PIP...."
+source $ROOT_DIR/env/bin/activate || die "Error activating virtualenv, exiting"
+pip install -r requirements.txt || die "Error while PIPing dependencies, exiting"
+printf "Done\n"
+
+# copy settings.sample to settings.py
+
+if [ -f etc/settings.py ]
+then
+    printf "Existing settings.py found.  Retaining\n"
+else
+    cp etc/settings.sample etc/settings.py || die_deactivate "\n\nError while creating settings.py, exiting"
+fi
+
+printf "\nConfiguration:\n"
+if [ $interactive == 0 ]
+then
+    syslog_enable="Y"
+    printf "Non-interactive mode detected\n"
+else
+    printf "Would you like to enable syslog support? [Y/n]"
+    read syslog_enable
+fi
+
+if [ $syslog_enable == "n" ]
+then
+    printf "\nSyslog Support disabled\n"
+else
+    sed -i 's/^SYSLOG_ENABLED\ =\ 0$/SYSLOG_ENABLED\ =\ 1/g' etc/settings.py || die_deactivate "\n\nError enabling syslog, existing"
+    operating_system=`uname` || printf "Operating system not detected, using default\n"; operating_system="default"
+
+    if [ $operating_system == 'Darwin' ]
+    then
+        sed -i 's/^#SYSLOG_ADDRESS\ =\ ('localhost',514)$/SYSLOG_ADDRESS\ =\ ('localhost',514)/g' etc/settings.py || die_deactivate "\n\nError enabling syslog, exiting"
+        printf "\nSyslog address set to localhost:514 for Darwin kernel\n"
+        
+    else
+        sed -i 's/^#SYSLOG_ADDRESS\ =\ \/dev\/log$/SYSLOG_ADDRESS\ =\ \/dev\/log/g' etc/settings.py || die_deactivate "\n\nError enabling syslog, exiting"
+        printf "\nSyslog address set to /dev/log\n"
+    fi
+fi
+
+# set DT_ROOT environment variable globally
+printf "Setting DT_ROOT environment variable for virtualenv"
+unset DT_ROOT
+printf "export DT_ROOT=%s" $ROOT_DIR > /etc/profile.d/dns_tools.sh || die_deactivate "Problem creating /etc/profile.d/dns_tools.sh, exiting"
+export DT_ROOT=$ROOT_DIR || die_deactivate "Problem exporting DT_ROOT environment variable, exiting"
+
+printf "\nInstallation Completed, please set DYN_USER and DYN_PASSWORD in your ~/.bash_profile or use the -U and -P flags in dyncl\n\n"
\ No newline at end of file
diff --git a/release_notes.txt b/release_notes.txt
new file mode 100644
index 0000000..2979f49
--- /dev/null
+++ b/release_notes.txt
@@ -0,0 +1,10 @@
+20151120 - jnegro - INF-65 Revamped arguments used in helpers so that they are consistent.  Also added auto-detect for zone in fqdn
+20151120 - jnegro - INF-66 Script output has a new formatter that was separated out of the module code, and is more consistent
+20151120 - jnegro - INF-155 Library reorganized and mostly rewritten to clean up old/bad ideas.  This also helped INF-65 and 66
+20151120 - jnegro - INF-328 Output bug did not occur with new module from INF-155
+20151120 - jnegro - INF-357 Error handling problem with an expected missing key value.  fixed
+20151022 - jnegro - INF-64 As a systems engineer I find the logging to be sub-par.  Added more standard, robust logging.
+20151019 - jnegro - INF-142 Password prompt was coming up on all runs of CLI
+20151019 - jnegro - INF-138 bug when trying to delete an A record when multiple records have been found
+20151016 - jnegro - INF-110 Fixed issues with HTTPRedirect resource, Added services helper to search for HTTPRedirect
+20151016 - jnegro - INF-137 Changed inline password option to be a prompt
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 8e98f76..de11dd3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
 argparse
-requests
+DynectDNS
\ No newline at end of file
diff --git a/settings.sample b/settings.sample
new file mode 100644
index 0000000..0ff2a1b
--- /dev/null
+++ b/settings.sample
@@ -0,0 +1,23 @@
+#dyn login info - Avoid using these hardcoded items and opt for user envars
+#ACCOUNT = 'advancedigital'
+#USER = 'username'
+#PASSWORD = 'password'
+
+#Sets the maximum attempts to get a job status before prompting
+JOB_STATUS_MAX_ATTEMPTS = 5
+
+#Sets the multiplier to increase the interval of checking for job status
+JOB_STATUS_STANDOFF_MULTIPLIER = 2
+
+#Admin contact prefix
+ADMIN_CONTACT = "domains@{0}"
+
+#Syslog
+SYSLOG_ENABLED = 0
+
+#Default Linux syslog path.  Socket will be tried first if specified.
+#SYSLOG_ADDRESS = '/dev/log'
+
+#Default OSX/BSD syslog path.  Address will be used if SYSLOG_SOCKET is not specified
+# or if SYSLOG_SOCKET path does not exist
+#SYSLOG_ADDRESS = ('localhost',514)
\ No newline at end of file