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
