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 DummyADTObject(sap.adt.ADTObject):
OBJTYPE = sap.adt.ADTObjectType(
'DUMMY/S',
'awesome/success',
xmlns_adtcore_ancestor('win', 'http://www.example.com/never/lose'),
'application/super.cool.txt+xml', {'text/plain': 'no/bigdeal'},
'dummies',
editor_factory=sap.adt.objects.ADTObjectSourceEditor)
def __init__(self,
connection='noconnection',
name='noobject',
metadata=None):
super(DummyADTObject, self).__init__(
connection, name,
metadata if metadata is not None else sap.adt.ADTCoreData(
description='adt fixtures dummy object'))
"""Odataservice ADT wrappers"""
from sap.errors import SAPCliError
from sap.platform.abap import (from_xml, Structure)
from sap.adt.objects import (xmlns_adtcore_ancestor, ADTObject, ADTObjectType,
OrderedClassMembers, ADTObjectReferences)
from sap.adt.annotations import (XmlNodeAttributeProperty, XmlNodeProperty,
XmlContainer)
from sap.adt.marshalling import Marshal
XMLNS_SRVB = xmlns_adtcore_ancestor(
'srvb', 'http://www.sap.com/adt/ddic/ServiceBindings')
XMLNS_SRVD = xmlns_adtcore_ancestor('srvd',
'http://www.sap.com/adt/ddic/srvdsources')
# pylint: disable=too-few-public-methods
class StatusMessage(Structure):
"""Status reported by the publish action"""
SEVERITY: str
SHORT_TEXT: str
LONG_TEXT: str
# pylint: disable=too-few-public-methods
class Definition(metaclass=OrderedClassMembers):
"""The node serviceBinding/services/content/serviceDefinition"""
uri = XmlNodeAttributeProperty('adtcore:uri')
typ = XmlNodeAttributeProperty('adtcore:type')
"""Object Checks ADT wrappers"""
from fnmatch import fnmatch
from sap.adt.objects import ADTObjectType, XMLNamespace, xmlns_adtcore_ancestor
from sap.adt.marshalling import Marshal
from sap.adt.annotations import OrderedClassMembers, XmlNodeAttributeProperty, XmlListNodeProperty, XmlElementKind, \
XmlContainer, XmlNodeProperty
XMLNS_CHKRUN = XMLNamespace('chkrun', 'http://www.sap.com/adt/checkrun')
XMLNS_CHKRUN_WITH_ADTCORE = xmlns_adtcore_ancestor('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)
def __init__(self, name=None):
self.name = name
def supports_type(self, obj_code):
"""Returns true if the give object code is supported"""
return any((fnmatch(obj_code, styp) for styp in self.supported_types))
def supports_object(self, adt_obj):
"""Returns true if the given object is supported"""
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
from typing import NamedTuple
from sap import get_logger
from sap.adt.objects import OrderedClassMembers, ADTObjectType, XMLNamespace, xmlns_adtcore_ancestor
from sap.adt.annotations import xml_element, XmlNodeProperty, xml_text_node_property, XmlContainer, \
XmlNodeAttributeProperty
from sap.adt.marshalling import Marshal
from sap.adt.datapreview import DataPreview
CUSTOMIZING_MIME_TYPE_V1 = 'application/vnd.sap.atc.customizing-v1+xml'
XMLNS_ATC = XMLNamespace('atc', 'http://www.sap.com/adt/atc')
XMLNS_ATCINFO = XMLNamespace('atcinfo', 'http://www.sap.com/adt/atc/info')
XMLNS_ATCWORKLIST = XMLNamespace('atcworklist',
'http://www.sap.com/adt/atc/worklist')
XMLNS_ATCOBJECT = xmlns_adtcore_ancestor('atcobject',
'http://www.sap.com/adt/atc/object')
XMLNS_ATCFINDING = XMLNamespace('atcfinding',
'http://www.sap.com/adt/atc/finding')
def mod_log():
"""Returns logger for this module"""
return get_logger()
class ATCCustomizingXMLHandler(ContentHandler):
"""ATC Customizing XML parser"""
def __init__(self, customizing):
""":param customizing: A object with the target attributes"""
super().__init__()
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
