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