class StatementsBulkRequest(metaclass=OrderedClassMembers): """ABAP StatementsBulkRequest """ objtype = ADTObjectType( None, 'runtime/traces/coverage/results/{identifier}/statements', XMLNS_COV, 'application/xml', None, 'statementsBulkRequest') def __init__(self, identifier, statement_requests=None): self.objtype.basepath = self.objtype.basepath.format( identifier=identifier) self._statement_requests = statement_requests or [] @xml_element('statementsRequest') def statement_requests(self): """Get statement requests :rtype: A list of :class:`StatementRequest` """ return self._statement_requests def add_statement_request(self, statement_request): """Adds the given statement request. """ self._statement_requests.append(statement_request) return statement_request
class CheckResults(metaclass=OrderedClassMembers): """Activation Run Check Results""" objtype = ADTObjectType(None, None, XMLNS_CHKL, None, None, 'messages') properties = XmlNodeProperty('chkl:properties', factory=CheckProperties) messages = XmlListNodeProperty('msg', value=[], factory=CheckMessage) @property def has_errors(self): """Returns true if the results contains an error message""" return any((message.is_error for message in self.messages)) @property def has_warnings(self): """Returns true if the results contains a warning message""" return any((message.is_warning for message in self.messages)) @property def generated(self): """Returns true if the activation left the objects generated""" if self.properties is None: return not self.has_errors return self.properties.generated != 'false'
class RunResponse(metaclass=OrderedClassMembers): """Worklist run Response""" objtype = ADTObjectType(None, None, XMLNS_ATCWORKLIST, 'application/xml', None, 'worklistRun') worklist_id = xml_text_node_property('atcworklist:worklistId') timestamp = xml_text_node_property('atcworklist:worklistTimestamp') infos = XmlNodeProperty('atcworklist:infos', factory=ATCInfoList)
def objtype(self): """Monkey Patch ADTObject""" return ADTObjectType(None, None, XMLNamespace('ioc', 'http://www.sap.com/abapxml/inactiveCtsObjects'), 'application/vnd.sap.adt.inactivectsobjects.v1+xml', None, 'inactiveObjects')
class ATCInfo(metaclass=OrderedClassMembers): """atcinfo:info XML Node""" objtype = ADTObjectType(None, None, XMLNS_ATCINFO, 'application/xml', None, 'info') typ = xml_text_node_property('atcinfo:type') description = xml_text_node_property('atcinfo:description') def __str__(self): return self.description
class ServiceDefinition(ADTObject): """Business Service Definition abstraction""" OBJTYPE = ADTObjectType('SRVD/SRV', 'ddic/srvd/sources', XMLNS_SRVD, ['application/vnd.sap.adt.ddic.srvd.v1+xml'], {}, 'srvdSource') def __init__(self, connection, name, package=None, metadata=None): super().__init__(connection, name, metadata) self._metadata.package_reference.name = package
class WorkList(metaclass=OrderedClassMembers): """atcworklist:worklist XML Node""" objtype = ADTObjectType(None, None, XMLNS_ATCWORKLIST, 'application/xml', None, 'worklist') worklist_id = XmlNodeAttributeProperty('atcworklist:id') timestamp = XmlNodeAttributeProperty('atcworklist:timestamp') used_objectset = XmlNodeAttributeProperty('atcworklist:usedObjectSet') object_set_is_complete = XmlNodeAttributeProperty('atcworklist:objectSetIsComplete') object_sets = XmlNodeProperty('atcworklist:objectSets', factory=WorkListObjectSetList) objects = XmlNodeProperty('atcworklist:objects', factory=ATCObjectList)
class ATCObject(metaclass=OrderedClassMembers): """atcobject:object XML Node""" objtype = ADTObjectType(None, None, XMLNS_ATCOBJECT, 'application/xml', None, 'object') uri = XmlNodeAttributeProperty('adtcore:uri') typ = XmlNodeAttributeProperty('adtcore:type') name = XmlNodeAttributeProperty('adtcore:name') package_name = XmlNodeAttributeProperty('adtcore:packageName') author = XmlNodeAttributeProperty('atcobject:author') object_type_id = XmlNodeAttributeProperty('atcobject:objectTypeId') findings = XmlNodeProperty('atcobject:findings', factory=ATCFindingList)
class Include(BaseProgram): """ABAP Program Include""" OBJTYPE = ADTObjectType( 'PROG/I', 'programs/includes', xmlns_adtcore_ancestor('include', 'http://www.sap.com/adt/programs/includes'), # application/vnd.sap.adt.programs.includes+xml, application/vnd.sap.adt.programs.includes.v2+xml 'application/vnd.sap.adt.programs.includes.v2+xml', {'text/plain': 'source/main'}, 'abapInclude', editor_factory=ADTObjectSourceEditor) def __init__(self, connection, name, package=None, metadata=None, master=None): super(Include, self).__init__(connection, name, package=package, metadata=metadata) self._master = master @property def uri(self): """Own version of URI which adds context with the master program""" uri = super(Include, self).uri if self.master is not None: master_uri = Program(self.connection, self.master).full_adt_uri master_uri = urllib.parse.quote(master_uri, safe='') uri = f'{uri}?context={master_uri}' return uri @property def master(self): """Returns name of the master program of this include""" return self._master @master.setter def master(self, value): """Sets name of the master program of this include""" self._master = value
class FunctionGroup(ADTObject): """ABAP Function Group""" OBJTYPE = ADTObjectType('FUGR/F', 'functions/groups', xmlns_adtcore_ancestor( 'group', 'http://www.sap.com/adt/functions/groups'), 'application/vnd.sap.adt.functions.groups.v2+xml', {'text/plain': 'source/main'}, 'abapFunctionGroup', editor_factory=ADTObjectSourceEditorWithResponse) def __init__(self, connection, name, package=None, metadata=None, active_status=None): super(FunctionGroup, self).__init__(connection, name, metadata=metadata, active_status=active_status) self._metadata.package_reference.name = package self._fixpntar = None @xml_attribute('abapsource:fixPointArithmetic') def fix_point_arithmetic(self): """Fixed point arithmetic flag""" return self._fixpntar @fix_point_arithmetic.setter def fix_point_arithmetic(self, value): """Fixed point arithmetic flag""" self._fixpntar = value == 'true' @classmethod def create_reference(cls, connection, name, package_name): """Builds reference to Function Group""" return ADTContainer( uri=f'/{connection.uri}/{cls.OBJTYPE.basepath}/{name.lower()}', object_type=cls.OBJTYPE.code, object_name=name, package_name=package_name)
class Query(metaclass=OrderedClassMembers): """ABAP Coverage Query """ objtype = ADTObjectType(None, 'runtime/traces/coverage/measurements/{identifier}', XMLNS_COV, 'application/xml', None, 'query') objects = XmlNodeProperty(XmlElementProperty.NAME_FROM_OBJECT) def __init__(self, identifier, objects): self.objtype.basepath = self.objtype.basepath.format(identifier=identifier) self.objects = objects
class RunRequest(metaclass=OrderedClassMembers): """Worklist run Request""" objtype = ADTObjectType(None, None, XMLNS_ATC, 'application/xml', None, 'run') max_verdicts = XmlNodeAttributeProperty('maximumVerdicts') def __init__(self, obj_sets, max_verdicts): """:param obj_sets: An instance of :class:`ADTObjectSets` :param max_verdicts: A number """ self._sets = obj_sets self.max_verdicts = max_verdicts @xml_element('objectSets') def sets(self): """Set of objects which we want to check""" return self._sets
class RunConfiguration(metaclass=OrderedClassMembers): """ABAP Unit Test run configuration Usage with all possible options re-set to default values: run = RunConfiguration() run.external.coverage.active = 'false' run.options.uri_type.value = UriTypeOptionValue.SEMANTIC run.options.test_determination_strategy.same_program = 'true' run.options.test_determination_strategy.assigned_tests = 'false' run.options.test_determination_strategy.append_assigned_tests_preview = 'true' run.options.test_risk_levels.harmless = 'true' run.options.test_risk_levels.dangerous = 'true' run.options.test_risk_levels.critical = 'true' run.options.test_durations.short = 'true' run.options.test_durations.medium = 'true' run.options.test_durations.long = 'true' run.options.with_navigation_uri.enabled = 'false' """ objtype = ADTObjectType( None, 'abapunit/testruns', XMLNS_AUNIT, 'application/vnd.sap.adt.abapunit.testruns.config.v4+xml', None, 'runConfiguration') external = XmlNodeProperty('external') options = XmlNodeProperty('options') objects = XmlNodeProperty(XmlElementProperty.NAME_FROM_OBJECT) def __init__(self, objects): self.external = RunConfigurationOptionsExternal() self.options = RunConfigurationOptions() self.objects = objects
class CheckObjectList(metaclass=OrderedClassMembers): """ADT run request items""" objtype = ADTObjectType(None, 'checkruns', XMLNS_CHKRUN_WITH_ADTCORE, 'application/vnd.sap.adt.checkobjects+xml', None, 'checkObjectList') objects = XmlListNodeProperty('chkrun:checkObject') def __iter__(self): return iter(self.objects) def add_uri(self, uri): """Adds the give URI to the list""" self.objects = CheckObject(uri) def add_object(self, adt_object): """Adds the give object to the list""" self.add_uri(adt_object.full_adt_uri)
XMLNS_CHKRUN = XMLNamespace('chkrun', 'http://www.sap.com/adt/checkrun') # pylint: disable=too-few-public-methods class Reporter(metaclass=OrderedClassMembers): """ADT Object Checks Run Reporter""" name = XmlNodeAttributeProperty('chkrun:name') supported_types = XmlListNodeProperty('chkrun:supportedType', kind=XmlElementKind.TEXT) # pylint: disable=invalid-name ReportersContainer = XmlContainer.define('chkrun:reporter', Reporter) ReportersContainer.objtype = ADTObjectType( None, 'checkruns/reporters', XMLNS_CHKRUN, 'application/vnd.sap.adt.reporters+xml', None, 'checkReporters') def fetch_reporters(connection): """Returns the list of supported ADT reporters""" reporters = ReportersContainer() resp = connection.execute('GET', reporters.objtype.basepath, accept=reporters.objtype.mimetype) Marshal.deserialize(resp.text, reporters) return reporters.items
class ServiceBinding(ADTObject): """Business Service binding abstraction""" OBJTYPE = ADTObjectType( 'SRVB/SVB', 'businessservices/bindings', XMLNS_SRVB, [ 'application/vnd.sap.adt.businessservices.servicebinding.v2+xml', 'application/vnd.sap.adt.businessservices.servicebinding.v1+xml' ], {}, 'serviceBinding') release_supported = XmlNodeAttributeProperty('srvb:releaseSupported') published = XmlNodeAttributeProperty('srvb:published') bindingCreated = XmlNodeAttributeProperty('srvb:bindingCreated') services = XmlNodeProperty('srvb:services', factory=ServicesContainer) binding = XmlNodeProperty('srvb:binding', factory=Binding) def __init__(self, connection, name, metadata=None): super().__init__(connection, name, metadata) def find_service(self, service_name=None, service_version=None): """Returns a first service matching the given parameters. If any parameter is None, the parameter is not considered for comparison. """ if service_name and service_version: return next((item for item in self.services if item.definition.name == service_name and item.version == service_version), None) if service_name is not None: return next((item for item in self.services if item.definition.name == service_name), None) if service_version is not None: return next( (item for item in self.services if item.version == service_version), None) raise SAPCliError( "You must specify either Service Name or Service Version or both") def publish(self, service): """Publish service definition""" references = ADTObjectReferences() references.add_object(self) response = self.connection.execute( 'POST', f'businessservices/{self.binding.term}/publishjobs', params={ 'servicename': self.name, 'serviceversion': service.version, }, headers={ # pylint: disable=line-too-long 'Accept': 'application/xml, application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.StatusMessage', 'Content-Type': 'application/xml' }, body=Marshal().serialize(references)) return from_xml(StatusMessage(), response.text, root_elem="DATA")
class FunctionModule(ADTObject): """ABAP Function Module""" OBJTYPE = ADTObjectType( 'FUGR/FF', 'functions/groups/{groupname}/fmodules', xmlns_adtcore_ancestor('fmodule', 'http://www.sap.com/adt/functions/fmodules'), [ 'application/vnd.sap.adt.functions.fmodules.v3+xml', 'application/vnd.sap.adt.functions.fmodules.v2+xml' ], {'text/plain': 'source/main'}, 'abapFunctionModule', editor_factory=ADTObjectSourceEditorWithResponse) def __init__(self, connection, name, function_group_name, metadata=None, active_status=None): super(FunctionModule, self).__init__(connection, name, metadata=metadata, active_status=active_status) self._function_group_name = function_group_name self._objtype = copy(FunctionModule.OBJTYPE) self._objtype.basepath = FunctionModule.OBJTYPE.basepath.format( groupname=function_group_name.lower()) self._processing_type = None self._reference = None self._release_state = None def _get_mime_and_version(self): # because the standard _get_mime_and_version() use basepath which # is modified in the __init__() method return find_mime_version(self.connection, FunctionModule.OBJTYPE) def language(self): """Not supported on Function Module level but Function Group level""" return None def master_language(self): """Not supported on Function Module level but Function Group level""" return None def master_system(self): """Not supported on Function Module level but Function Group level""" return None def responsible(self): """Not supported on Function Module level but Function Group level""" return None def reference(self): """Function Module has no Package reference but containerRef""" return None @property def objtype(self): """ADT type definition which is built for each instance and is not per class like othe ADT Objects. """ return self._objtype @xml_attribute('fmodule:processingType') def processing_type(self): """Returns processing type : RFC or BAPI or Local""" return self._processing_type @processing_type.setter def processing_type(self, value): """Sets processing type : RFC or BAPI or Local""" self._processing_type = value @xml_attribute('fmodule:releaseState') def release_state(self): """"Attribute Release State""" return self._release_state @release_state.setter def release_state(self, value): """"Attribute Release State""" self._release_state = value @xml_element('adtcore:containerRef') def function_group_reference(self): """Returns parent Function Group reference""" if self._reference is None: self._reference = FunctionGroup.create_reference( self.connection, self._function_group_name, self.package) return self._reference
class Package(ADTObject): """ABAP Package - Development class - DEVC""" OBJTYPE = ADTObjectType( 'DEVC/K', 'packages', xmlns_adtcore_ancestor('pak', 'http://www.sap.com/adt/packages'), [ 'application/vnd.sap.adt.packages.v2+xml', 'application/vnd.sap.adt.packages.v1+xml' ], {}, 'package') class Attributes(metaclass=OrderedClassMembers): """SAP Package attributes. """ def __init__(self, name=None): self._package_type = name @xml_attribute('pak:packageType') def package_type(self): """The Package's type """ return self._package_type @package_type.setter def package_type(self, value): """The Package's type setter """ self._package_type = value class Transport(metaclass=OrderedClassMembers): """SAP Package transport details. """ def __init__(self): self._software_component = Reference() self._layer = Reference() @xml_element('pak:softwareComponent') def software_component(self): """The Package's software component """ return self._software_component @software_component.setter def software_component(self, value): """The Package's software component setter """ self._software_component = value @xml_element('pak:transportLayer') def transport_layer(self): """The Package's transport layer """ return self._layer @transport_layer.setter def transport_layer(self, value): """Set's the transport layer""" self._layer = value def __init__(self, connection, name, metadata=None): super(Package, self).__init__(connection, name, metadata) self._superpkg = ADTCoreData.Reference() self._transport = Package.Transport() self._attributes = Package.Attributes() self._metadata.package_reference.name = name self._appcomp = Reference() # pylint: disable=no-self-use @xml_attribute('adtcore:version', deserialize=False) def active(self): """Version in regards of activation""" return "active" @xml_element('pak:attributes') def attributes(self): """The package's attributes. """ return self._attributes @xml_element('pak:superPackage') def super_package(self): """The package's super package. """ return self._superpkg @xml_element('pak:applicationComponent') # pylint: disable=no-self-use def app_component(self): """The package's application component """ return self._appcomp @xml_element('pak:transport') def transport(self): """The package's transport configuration. """ return self._transport @xml_element('pak:translation', deserialize=False) # pylint: disable=no-self-use def translation(self): """The package's translation flag """ return None @xml_element('pak:useAccesses', deserialize=False) # pylint: disable=no-self-use def use_accesses(self): """The package's Use Accesses """ return None @xml_element('pak:packageInterfaces', deserialize=False) # pylint: disable=no-self-use def package_interfaces(self): """The package's Interfaces """ return None @xml_element('pak:subPackages', deserialize=False) # pylint: disable=no-self-use def sub_packages(self): """The package's sub-packages """ return None def set_package_type(self, package_type): """Changes the Package's type """ self._attributes.package_type = package_type def set_software_component(self, name): """Changes the Package's software component """ self._transport.software_component.name = name def set_transport_layer(self, name): """Changes the Package's transport layer """ self._transport.transport_layer.name = name def set_app_component(self, name): """Changes the Package's software component """ self._appcomp.name = name
class Program(BaseProgram): """ABAP Report/Program """ OBJTYPE = ADTObjectType('PROG/P', 'programs/programs', xmlns_adtcore_ancestor( 'program', 'http://www.sap.com/adt/programs/programs'), 'application/vnd.sap.adt.programs.programs.v2+xml', {'text/plain': 'source/main'}, 'abapProgram', editor_factory=ADTObjectSourceEditor) class LogicalDatabase(metaclass=OrderedClassMembers): """Logical database ADT element""" def __init__(self): self._ref = ADTCoreData.Reference() @xml_element('program:ref') def reference(self): """Returns reference""" return self._ref def __init__(self, connection, name, package=None, metadata=None): super().__init__(connection, name, package=package, metadata=metadata) self._program_type = None self._logical_dabase = Program.LogicalDatabase() @xml_attribute('program:programType') def program_type(self): """Returns program type""" return self._program_type @program_type.setter def program_type(self, value): """Sets value of Program Type""" types = {'executableProgram': '1'} self._program_type = types[value] # pylint: disable=no-self-use @property def case_sensitive(self): """True if the program is case sensitive""" return True # pylint: disable=no-self-use @property def application_database(self): """Application database""" return 'S' @xml_element('program:logicalDatabase') def logical_database(self): """Logical database configuration""" return self._logical_dabase