Attachment #5596 for bug #33223




# FIXME: What is the use of the following line?
# __path__.append("users")


# manages properties
class base(object):
	def __init__(self, co, lo, position, dn='', superordinate = None ):

		return self.descriptions.keys()

	def items(self):

		# this returns emtpy strings resp. empty lists for attributes not set
		r=[]
		for key in self.keys():



class simpleLdap(base):

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
		global s4connector_present
		global s4connector_search

	def description(self):
		if self.dn:
			rdn = self.lo.explodeDn(self.dn)[0]
			return rdn[rdn.find('=') + 1:]
		else:
			return 'none'


		self.exceptions=[]

		# remove all properties which do not belong to chosen options

		chosen_options = None
		descriptions = None

		try:
			# these might not be set by an inheriting module
			chosen_options = self.options
			descriptions = self.descriptions
		except:
			chosen_options = None
			descriptions = None

		if chosen_options and descriptions:
			for desc in descriptions:
				propoptions = descriptions[desc].options

				if not propoptions:
					# property applies to all options
					continue

				if set(propoptions) & set(chosen_options):
					# this property applies to one of the chosen options,
					# jump to next option
					if i in chosen_options:
						# this property applies to one of the chosen options,
						# jump to next option
						shortcut = True
						continue
				if shortcut:
					continue

				# if we've come here, we found a property that does not apply

				ml.append(('objectClass', self.oldattr.get('objectClass', []), self.oldattr.get('objectClass', [])+['univentionPolicyReference']))
			ml.append(('univentionPolicyReference', self.oldpolicies, self.policies))


		return ml

	def _create(self):

		self.save()
		return self.dn

	#+++# MODIFY #+++#
	def _modify(self, modify_childs=1, ignore_license=0):
		self.exceptions=[]


		# iterate over all properties and call checkLdap() of corresponding syntax
		self._call_checkLdap_on_all_property_syntaxes()

		#+++# MODLIST #+++#
		ml=self._ldap_modlist()
		# custom attributes
		m=univention.admin.modules.get(self.module)

							ml.remove(i)
						ml.extend( addlist )


					else:
						if deleteObjectClass == '1' and not self.info.has_key(pname):
							# value is empty, should delete objectClass and Values

					ml.append( ('objectClass', self.oldattr.get('objectClass'), current_ocs+[prop.objClass]) )

				else:

					if prop.syntax == 'boolean' and self.info.has_key(prop.name) and self.info[prop.name] == '0':
						# syntax is boolean and value == 0 ==> remove
						dellist = []

			self.policyObjects[policy_type]=univention.admin.objects.get(policy_module, None, self.lo, policy_position)
			self.policyObjects[policy_type].copyIdentifier(self)
			self._init_ldap_search( self.policyObjects[ policy_type ] )
		else:
			pass

		return self.policyObjects[policy_type]


		zoneName.reverse( )
		relativeDomainName = relativeDomainName.split( '.' )
		relativeDomainName.reverse( )
		return '.'.join(zoneName + relativeDomainName)

	def __ip_from_ptr_ipv6( self, zoneName, relativeDomainName ):
		fullName = relativeDomainName + '.' + zoneName.replace('.ip6.arpa', '')

				object[ 'host' ] = object[ 'host' ].replace( old_name, new_name )
				object.modify( )


	def __remove_from_dhcp_object( self, position = None, name = None, oldname = None, mac = None, ip = None ):
		# if we got the mac addres, then we remove the object
		# if we only got the ip addres, we remove the ip address

		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'we should remove a dhcp object: position="%s", name="%s", oldname="%s", mac="%s", ip="%s"' % ( position, name, oldname, mac, ip ) )

		dn = None

		tmppos = univention.admin.uldap.position( self.position.getDomain( ) )

					for dn2, attributes2 in self.lo.search(scope='domain', attr=[ 'zoneName' ], filter='(&(relativeDomainName=%s)(objectClass=dNSZone))' %  name, unique=0 ):
						self.lo.modify( dn, [('pTRRecord', '%s.%s.' % (name, attributes2['zoneName'][0]), '')] )

				zone = univention.admin.handlers.dns.reverse_zone.object( self.co, self.lo, self.position, zoneDN)
				zone.open()
				zone.modify()


		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'we should remove a dns reverse object: dnsEntryZoneReverse="%s", name="%s", ip="%s"' % ( dnsEntryZoneReverse, name, ip ) )
		if dnsEntryZoneReverse:
			rdn = self.calc_dns_reverse_entry_name( ip, dnsEntryZoneReverse )

						modify(rdn, zone)
					except univention.admin.uexceptions.noObject:
						pass

	def __add_dns_reverse_object( self, name, zoneDn, ip ):
		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'we should create a dns reverse object: zoneDn="%s", name="%s", ip="%s"' % ( zoneDn, name, ip ) )
		if name and zoneDn and ip:

		for dn, attributes in self.lo.search(base=zoneDN, scope='domain', attr=['pTRRecord'], filter=search_filter):
			self.lo.modify(dn, [('pTRRecord', '', ptrrecord)])



	def __remove_related_ptrrecords(self, zoneDN, ip):
		ptrrecord = '%s.%s.' % (self.info['name'], zoneDN.split('=')[1].split(',')[0])
		ip_split = ip.split('.')

		for dn, attributes in self.lo.search(base=zoneDN, scope='domain', attr=['pTRRecord'], filter=search_filter):
			if ptrrecord in attributes['pTRRecord']:
				self.lo.modify(dn, [('pTRRecord', ptrrecord, '')])
		

	def check_common_name_length(self):
		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'check_common_name_length with self["ip"] = %r and self["dnsEntryZoneForward"] = %r' % (self['ip'], self['dnsEntryZoneForward'], ))

					else:
						self.lo.modify( dn, [ ( 'aRecord', '' ,  ip ) ] )


	def __add_dns_alias_object( self, name, dnsForwardZone, dnsAliasZoneContainer, alias ):
		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'add a dns alias object: name="%s", dnsForwardZone="%s", dnsAliasZoneContainer="%s", alias="%s"' % ( name, dnsForwardZone, dnsAliasZoneContainer, alias ) )
		if name and dnsForwardZone and dnsAliasZoneContainer and alias:

			else:
				# thow exeption, cNAMERecord is single value
				raise univention.admin.uexceptions.dnsAliasAlreadyUsed, _('DNS alias is already in use.')
		pass

	def __remove_dns_alias_object( self, name, dnsForwardZone, dnsAliasZoneContainer, alias = None ):
		univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'remove a dns alias object: name="%s", dnsForwardZone="%s", dnsAliasZoneContainer="%s", alias="%s"' % ( name, dnsForwardZone, dnsAliasZoneContainer, alias ) )

					pass

	def _ldap_post_modify( self ):
		self.__multiip |= len(self['mac']) > 1 or len(self['ip']) > 1
		if len ( self[ 'mac' ] ) > 1 or len( self[ 'ip' ] ) > 1:
			self.__multiip = True

		for entry in self.__changes[ 'dhcpEntryZone' ][ 'remove' ]:
			univention.debug.debug( univention.debug.ADMIN, univention.debug.INFO, 'simpleComputer: dhcp check: removed: %s' % entry )

			else:
				self.__add_dns_reverse_object( self[ 'name' ], dn, ip )


		for entry in self.__changes[ 'dnsEntryZoneAlias' ][ 'remove' ]:
			dnsForwardZone, dnsAliasZoneContainer, alias = entry
			if not alias:

			self.__update_groups_after_namechange()
			self.__rename_dhcp_object( position = None, old_name = self.__changes[ 'name' ][ 0 ], new_name = self.__changes[ 'name' ][ 1 ] )
			self.__rename_dns_object( position = None, old_name = self.__changes[ 'name' ][ 0 ], new_name = self.__changes[ 'name' ][ 1 ] )
			pass

		if self.ipRequest == 1 and self[ 'ip' ]:
			for ipAddress in self[ 'ip' ]:


	def __remove_associated_domain( self, entry ):
		dn, ip = self.__split_dns_line( entry )
		domain = ldap.explode_rdn(dn)[0].split('=', 1)[1]
		if self.info.get('domain', None) == domain:
			self.info['domain'] = None

	def __set_associated_domain( self, entry ):
		dn, ip = self.__split_dns_line( entry )
		domain = ldap.explode_rdn(dn)[0].split('=', 1)[1]
		if not self.info.get('domain', None):
			self.info['domain'] = domain


	def _ldap_modlist( self ):
		self.__changes =  {	'mac': {'remove': [ ], 'add': [ ]}, 'ip': {'remove': [ ], 'add': [ ]}, 'name': None,
							'dnsEntryZoneForward': { 'remove': [ ], 'add': [ ] },

		newAaaaRecord = []
		if oldAddresses != newAddresses:
			if oldAddresses:
				for address in oldAddresses:
					if ':' in address: # IPv6
						oldAaaaRecord.append(address)
					else:
						oldARecord.append(address)
			if newAddresses:
				for address in newAddresses:
					if ':' in address: # IPv6
						newAaaaRecord.append(ipaddr.IPv6Address(address).exploded)
					else:

						continue
					self.__changes[ 'ip' ][ 'remove' ].append( ipAddress )


		if self.hasChanged( 'name' ):
			ml.append( ( 'sn', self.oldattr.get( 'sn', [ None ] )[ 0 ], self[ 'name' ] ) )
			self.__changes[ 'name' ] = ( self.oldattr.get( 'sn', [ None ] )[ 0 ], self[ 'name' ] )

		if self.hasChanged('ip') or self.hasChanged('mac'):

			if len(self.info.get('ip', [])) == 1 and len(self.info.get('mac', [])) == 1 and len(self.info.get('dhcpEntryZone', [])):
				# In this special case, we assume the mapping between ip/mac address to be
				# unique. The dhcp entry needs to contain the mac address (as sepcified by
				# the ldap search for dhcp entries), the ip address may not correspond to
				# the ip address associated with the computer ldap object, but this would
				# be erroneous anyway. We therefore update the dhcp entry to correspond to
				# the current ip and mac address. (Bug #20315)
				dn, ip, mac = self.__split_dhcp_line( self.info['dhcpEntryZone'][0] )


				else:
					raise univention.admin.uexceptions.invalidDNSAliasEntry, _('The DNS alias entry for this host should contain the zone name, the alias zone container LDAP-DN and the alias.')

		self.__multiip = len(self['mac']) > 1 or len(self['ip']) > 1
			self.__multiip = False
		else:
			self.__multiip = True

		ml += super(simpleComputer, self)._ldap_modlist()

		return ml


			subnet=ldap.explode_dn(reverseDN, 1)[0].replace('.in-addr.arpa','').split('.')
			ip=sip.split('.')
			return self.calc_dns_reverse_entry_name_do(4, subnet, ip)

	def calc_dns_reverse_entry_name_do(self, maxLength, zoneNet, ip):
		zoneNet.reverse()
		if not ip[:len(zoneNet)] == zoneNet:

			else:
				self.__modify_dhcp_object( dn, self[ 'name' ], ip, mac )


		for entry in self.__changes[ 'dnsEntryZoneForward' ][ 'remove' ]:
			dn, ip = self.__split_dns_line( entry )
			if not ip and not self.__multiip:

			groupObject = univention.admin.objects.get(univention.admin.modules.get('groups/group'), self.co, self.lo, self.position, group)
			groupObject.fast_member_remove( [ self.dn ], self.oldattr.get('uid',[]), ignore_license=1 )


	def __update_groups_after_namechange(self):
		oldname = self.oldinfo.get('name')
		newname = self.info.get('name')


			self.lo.modify(group, [('uniqueMember', oldUniqueMembers, newUniqueMembers), ('memberUid', oldMemberUids, newMemberUids)])


	def update_groups(self):
		if not self.hasChanged('groups') and \
			   not ('oldPrimaryGroupDn' in self.__dict__ and self.oldPrimaryGroupDn) and \

				groupObject['hosts'].remove(self.dn)
				groupObject.modify(ignore_license=1)


	def primary_group(self):
		if not self.hasChanged('primaryGroup'):
			return

							self.__saved_dhcp_entry = network_object['dhcpEntryZone']

					self.old_network=value
				else:
					pass


		elif key == 'ip':
			self.ip_freshly_set = True

		if raise_after:
			raise raise_after

class simpleLdapSub(simpleLdap):

class simpleLdapSub(simpleLdap):
	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
		base.__init__(self, co, lo, position, dn, superordinate )


		if hasattr(self,"_ldap_post_remove"):
			self._ldap_post_remove()


class simplePolicy(simpleLdap):
	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):

		self.resultmode=0
		self.dn=dn


		self.policy_result()

		if self.polinfo.has_key(key):

			if self.polinfo[key] != newvalue or self.polinfo_more[key]['policy'] == self.cloned or ( self.info.has_key( key ) and self.info[ key ] != newvalue ):
				if self.polinfo_more[key]['fixed'] and self.polinfo_more[key]['policy'] != self.cloned:
					raise univention.admin.uexceptions.policyFixedAttribute, key

				if self.hasChanged(key):
					univention.debug.debug(univention.debug.ADMIN, univention.debug.INFO, 'polinfo: key:%s hasChanged' % (key) )
					self.changes=1
			return
			else:
				return

		# this object did not exist before
		if not self.oldinfo:




# /usr/share/common-licenses/AGPL-3; if not, see
# <http://www.gnu.org/licenses/>.

import sys

import univention.admin.localization
from univention.admin.layout import Tab
from univention.admin.handlers import simpleLdap

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate


_options = {
	'options': univention.admin.option(
		short_description=_('Allow custom DHCP options'),
		long_description=_("Allow adding custom DHCP options. Experts only!"),
		default=False,
		editable=True,
		objectClasses=['dhcpOptions'],
	),
}


_properties = {
	'option': univention.admin.property(
		short_description=_('DHCP options'),
		long_description=_('Defines additional DHCP options.'),
		syntax=univention.admin.syntax.string,
		multivalue=True,
		options=["options"],
		required=False,
		may_change=True,
		identifies=False,
	),
}

# def optionMap( value ):
# 	return map( lambda x: ' '.join( x ), value )

def rangeMap(value):
	return map(lambda x: ' '.join(x), value)


def rangeUnmap(value):
	return map(lambda x: x.split(), value)


_mappings = (
	('option', 'dhcpOption', None, None),
)


def add_dhcp_options(module_name):
	module = sys.modules[module_name]

	options = getattr(module, "options")
	options.update(_options)

	properties = getattr(module, "property_descriptions")
	properties.update(_properties)

	mapping = getattr(module, "mapping")
	for item in _mappings:
		mapping.register(*item)

	layout = getattr(module, "layout")
	layout.append(Tab(
		_('DHCP options'),
		_('Custom DHCP options'),
		advanced=True,
		layout=['option']
	))


class SimpleDhcp(simpleLdap):
	@classmethod
	def lookup(cls, co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
		filter_str = unicode(cls.lookup_filter(filter_s))
		res = [
			cls(co, lo, None, dn=dn, superordinate=superordinate, attributes=attrs)
			for dn, attrs in lo.search(filter_str, base, scope, [], unique, required, timeout, sizelimit)
		]
		return res


class DhcpOptions(SimpleDhcp):
	def setup_options(self, options):
		self.options = []
		self._define_options(options)

	def open(self):
		super(DhcpOptions, self).open()
		try:
			ocs = self.oldattr['objectClass']
			if "dhcpOptions" in ocs:
				self.options.append("options")
		except LookupError:
			pass
		self.old_options = list(self.options)

	def _ldap_modlist(self):
		if "options" not in self.options:
			del self.info.get('option', [])[:]

		mod_list = super(DhcpOptions, self)._ldap_modlist()
	#layout.append( Tab( _( 'Advanced' ), _( 'Advanced DHCP options' ), layout = [ 'option' ] ) )

		old_ocs = self.oldattr.get('objectClass', [])
		if self.info.get('option', []):
			if 'dhcpOptions' not in old_ocs:
				new_ocs = old_ocs + ['dhcpOptions']
				mod_list.append(('objectClass', old_ocs, new_ocs))
		elif "options" not in self.options and 'dhcpOptions' in old_ocs:
			new_ocs = list(old_ocs)
			new_ocs.remove("dhcpOptions")
			mod_list.append(('objectClass', old_ocs, new_ocs))

		return mod_list




import univention.admin.handlers.dhcp.subnet


translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate


module = 'dhcp/dhcp'

childs = 0
short_description = _('DHCP')
long_description = ''
operations = ['search']
usewizard = 1
wizardmenustring = _("DHCP")
wizarddescription = _("Add, edit and delete DHCP objects")
wizardoperations = {
	"add": [_("Add"), _("Add DHCP object")],
	"find": [_("Search"), _("Search DHCP object(s)")],
}
wizardpath = "univentionDhcpObject"
wizardsuperordinates = ('None', 'dhcp/service', 'dhcp/shared')
wizardtypesforsuper = {
	'None': ('dhcp/service',),
	'dhcp/service': ('dhcp/host', 'dhcp/server', 'dhcp/shared', 'dhcp/subnet'),
	'dhcp/shared': ('dhcp/sharedsubnet',)
}

childmodules = [
	"dhcp/host",
	"dhcp/pool",
	"dhcp/server",
	"dhcp/service",
	"dhcp/shared",
	"dhcp/sharedsubnet",
	"dhcp/subnet",
]
virtual = 1

options = {
}

property_descriptions = {
	'name': univention.admin.property(
		short_description=_('Name'),
		long_description='',
		syntax=univention.admin.syntax.string,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=True,
		identifies=True
	)
}

layout = [Tab(_('General'), _('Basic settings'), layout=["name"])]

mapping = univention.admin.mapping.mapping()


class object(univention.admin.handlers.simpleLdap):
	module = module

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.mapping = mapping
		self.descriptions = property_descriptions

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.descriptions=property_descriptions

		univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )


def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
	ret = []
	if superordinate:
		ret += univention.admin.handlers.dhcp.host.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
		ret += univention.admin.handlers.dhcp.pool.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
		ret += univention.admin.handlers.dhcp.server.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
		ret += univention.admin.handlers.dhcp.shared.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
		ret += univention.admin.handlers.dhcp.sharedsubnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
		ret += univention.admin.handlers.dhcp.subnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
	else:
		ret += univention.admin.handlers.dhcp.service.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
	return ret


def identify(dn, attr, canonical=0):
	pass






import univention.admin.filter
import univention.admin.handlers
import univention.admin.localization
import univention.debug as ud

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/host'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/service'
childs = 0
usewizard = 1
short_description = _('DHCP: Host')
long_description = ''

options = {
}

property_descriptions = {
	'host':  univention.admin.property(
		short_description=_('Hostname'),
		long_description='',
		syntax=univention.admin.syntax.string,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=True,
		identifies=True
	),
	'hwaddress': univention.admin.property(
		short_description=_('Hardware address'),
		long_description=_(
			'Currently, only the ethernet and token-ring types are recognized.'
			'The hardware-address should be a set of hexadecimal octets (numbers from 0 through ff) separated by colons.'),
		syntax=univention.admin.syntax.DHCP_HardwareAddress,
		multivalue=False,
		options=[],
		required=True,
		may_change=True,
		identifies=False
	),
	'fixedaddress': univention.admin.property(
		short_description=_('Fixed IP addresses'),
		long_description=_(
			'Assign one or more fixed IP addresses.'
			'Each address should be either an IP address or a domain name that resolves to one or more IP addresses'),
		syntax=univention.admin.syntax.string,
		multivalue=True,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			'host',
			'hwaddress',
			'fixedaddress'
		]),
	])
]


def unmapHWAddress(old):
	ud.debug(ud.ADMIN, ud.INFO, 'host.py: unmapHWAddress: old: %s' % old)
	if not old:
		return ['', '']
	return old[0].split(' ')


def mapHWAddress(old):
	ud.debug(ud.ADMIN, ud.INFO, 'host.py: mapHWAddress: old: %s' % old)
	if not old[0]:
		return ''
	else:
		if len(old) > 1:
			return '%s %s' % (old[0], old[1])
		else:
			return old


mapping = univention.admin.mapping.mapping()
mapping.register('host', 'cn', None, univention.admin.mapping.ListToString)
mapping.register('hwaddress', 'dhcpHWAddress', mapHWAddress, unmapHWAddress)
mapping.register('fixedaddress', 'univentionDhcpFixedAddress')

from .__common import add_dhcp_options, DhcpOptions
add_dhcp_options(__name__)

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
		global mapping
		global property_descriptions

class object(DhcpOptions):
	module = module

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)

	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('host'),
			mapping.mapValue('host', self.info['host']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'univentionDhcpHost']),
		]

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.expression('objectClass', 'univentionDhcpHost')
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj

	filter=univention.admin.filter.conjunction('&', [
	univention.admin.filter.expression('objectClass', 'univentionDhcpHost')
	])

lookup_filter = object.lookup_filter
lookup = object.lookup
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

	res=[]
	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
		res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
	return res

def identify(dn, attr):

	return 'univentionDhcpHost' in attr.get('objectClass', [])




# <http://www.gnu.org/licenses/>.

import copy
import string

from univention.admin.layout import Tab, Group
import univention.admin.filter

import univention.admin.localization
import univention.admin.uexceptions

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/pool'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/subnet'
childs = 0
usewizard = 1
short_description = _('DHCP: Pool')
long_description = ''

options = {
}

property_descriptions = {
	'name': univention.admin.property(
		short_description=_('Name'),
		long_description=_('A unique name used to identify this pool, e.g. "known" or "guests"'),
		syntax=univention.admin.syntax.string,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=False,
		identifies=True
	),
	'range': univention.admin.property(
		short_description=_('IP range for dynamic assignment'),
		long_description='',
		syntax=univention.admin.syntax.IPv4_AddressRange,
		multivalue=True,
		options=[],
		required=True,
		may_change=True,
		identifies=False
	),
	'failover_peer': univention.admin.property(
		short_description=_('Failover peer'),
		long_description=_('The name of a failover configuration manually configured in /etc/dhcp/local.conf.'),
		syntax=univention.admin.syntax.string,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False,
	),
	'known_clients': univention.admin.property(
		short_description=_('Give IP to known clients'),
		long_description=_('Addresses are allocated for client, which have a host entry matching their MAC address.'),
		syntax=univention.admin.syntax.AllowDeny,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
	'unknown_clients': univention.admin.property(
		short_description=_('Give IP to unknown clients'),
		long_description=_('Addresses are allocated for clients, which do not have a host entry mating their MAC address.'),
		syntax=univention.admin.syntax.AllowDeny,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
	'dynamic_bootp_clients': univention.admin.property(
		short_description=_('Give IP to dynamic BOOTP clients'),
		long_description=_(
			'Give addresses to clients using the legacy BOOTP protocol.'
			'Since BOOTP does not support an expiry date or a release mechanism, addresses are allocated indefinitely!'),
		syntax=univention.admin.syntax.AllowDeny,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
	'all_clients': univention.admin.property(
		short_description=_('Give IP from this pool'),
		long_description=_('Give addresses from this pool at all or not.'),
		syntax=univention.admin.syntax.AllowDeny,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
}

options = {
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			'name',
			'range'
		]),
	]),
	Tab(_('Advanced'), _('Advanced DHCP pool options'), advanced=True, layout=[
		'failover_peer',
		['known_clients', 'unknown_clients'],
		['dynamic_bootp_clients', 'all_clients']
	])
]

def rangeMap( value ):
	return map( lambda x: ' '.join( x ), value )

from .__common import rangeMap, rangeUnmap, add_dhcp_options, DhcpOptions
	return map( lambda x: x.split( ' ' ), value )

mapping = univention.admin.mapping.mapping()
mapping.register('name', 'cn', None, univention.admin.mapping.ListToString)
mapping.register('range', 'dhcpRange', rangeMap, rangeUnmap)
mapping.register('failover_peer', 'univentionDhcpFailoverPeer', None, univention.admin.mapping.ListToString)

add_dhcp_options(__name__)
	module=module

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
		global mapping
		global property_descriptions

class object(DhcpOptions):
	module = module

	permits_udm2dhcp = {
		'known_clients': "known clients",
		'unknown_clients': "unknown clients",
		'dynamic_bootp_clients': "dynamic bootp clients",
		'all_clients': "all clients",
	}
	permits_dhcp2udm = dict((value, key) for (key, value) in permits_udm2dhcp.items())

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)

	def open(self):
		super(object, self).open()
		univention.admin.handlers.simpleLdap.open(self)

		for i in self.oldattr.get('dhcpPermitList', []):
			permit, name = i.split(' ', 1)
			prop = self.permits_dhcp2udm[name]
			self[prop] = permit
			if name == 'known clients':
				self['known_clients']=permit
			elif name == 'unknown clients':
				self['unknown_clients']=permit
			elif name == 'dynamic bootp clients':
				self['dynamic_bootp_clients']=permit
			elif name == 'all clients':
				self['all_clients']=permit

		self.save()


	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('name'),
			mapping.mapValue('name', self.info['name']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'univentionDhcpPool']),
		]

	def _ldap_modlist(self):
		ml = super(object, self)._ldap_modlist()
		if self.hasChanged(self.permits_udm2dhcp.keys()):
			old = self.oldattr.get('dhcpPermitList', [])
			new = copy.deepcopy(old)
			for prop, value in self.permits_udm2dhcp.items():
				try:
					permit = self.oldinfo[prop]
					new.remove("%s %s" % (permit, value))
				except LookupError:
					pass
				try:
					permit = self.info[prop]
					new.append("%s %s" % (permit, value))
				except LookupError:
					pass
			if self.oldinfo.has_key('dynamic_bootp_clients') and self.oldinfo['dynamic_bootp_clients']:
				new.remove(self.oldinfo['dynamic_bootp_clients']+' dynamic bootp clients')
			if self.info.has_key('dynamic_bootp_clients') and self.info['dynamic_bootp_clients']:
				new.append(self.info['dynamic_bootp_clients']+' dynamic bootp clients')
			
			if self.oldinfo.has_key('all_clients') and self.oldinfo['all_clients']:
				new.remove(self.oldinfo['all_clients']+' all clients')
			if self.info.has_key('all_clients') and self.info['all_clients']:
				new.append(self.info['all_clients']+' all clients')
				
			ml.append(('dhcpPermitList', old, new))

		if self.info.get('failover_peer', None) and not self.info.get('dynamic_bootp_clients', None) == 'deny':
			raise univention.admin.uexceptions.bootpXORFailover

		return ml

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.expression('objectClass', 'univentionDhcpPool')
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj

	filter=univention.admin.filter.conjunction('&', [
	univention.admin.filter.expression('objectClass', 'univentionDhcpPool')
	])

lookup_filter = object.lookup_filter
lookup = object.lookup
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

	res=[]
	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
		res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
	return res

def identify(dn, attr):
	return 'univentionDhcpPool' in attr.get('objectClass', [])




import univention.admin.handlers
import univention.admin.localization

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/server'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/service'
childs = 0
usewizard = 1
short_description = _('DHCP: Server')
long_description = ''

options = {
}

property_descriptions = {
	'server': univention.admin.property(
		short_description=_('Server name'),
		long_description='',
		syntax=univention.admin.syntax.string,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=True,
		identifies=True
	),
}

layout = [
	Tab(_('General'), _('General settings'), layout=[
		Group(_('General'), layout=[
			'server'
		]),
	])
]

mapping = univention.admin.mapping.mapping()
mapping.register('server', 'cn', None, univention.admin.mapping.ListToString)

from .__common import add_dhcp_options
add_dhcp_options(__name__)

add_dhcp_options( property_descriptions, mapping, layout )

class object(univention.admin.handlers.simpleLdap):
	module = module

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
		global mapping
		global property_descriptions

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.superordinate = superordinate
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)

	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('server'),
			mapping.mapValue('server', self.info['server']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		searchBase = self.position.getDomain()
		if self.lo.searchDn(base=searchBase, filter='(&(objectClass=dhcpServer)(cn=%s))' % (self.info['server'])):
			raise univention.admin.uexceptions.dhcpServerAlreadyUsed, self.info['server']


			('objectClass', ['top', 'dhcpServer']),
			('dhcpServiceDN', self.superordinate.dn),
		]

	def _ldap_post_move(self, olddn):
		'''edit dhcpServiceDN'''
		oldServiceDN = self.lo.getAttr(self.dn, 'dhcpServiceDN')
		module = univention.admin.modules.identifyOne(self.position.getDn(), self.lo.get(self.position.getDn()))
		object = univention.admin.objects.get(module, None, self.lo, self.position, dn=self.position.getDn())
		shadow_module, shadow_object = univention.admin.objects.shadow(self.lo, module, object, self.position)
		self.lo.modify(self.dn, [('dhcpServiceDN', oldServiceDN[0], shadow_object.dn)])

def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):

def lookup_filter(filter_s=None, lo=None):
	filter_obj = univention.admin.filter.conjunction('&', [
		univention.admin.filter.expression('objectClass', 'dhcpServer')
	])
	filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
	return filter_obj

	if superordinate:
		filter.expressions.append(univention.admin.filter.expression('dhcpServiceDN', superordinate.dn))

def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
	filter_obj = lookup_filter(filter_s)
	if superordinate:
		filter_obj.expressions.append(univention.admin.filter.expression('dhcpServiceDN', superordinate.dn))
	filter_str = unicode(filter_obj)

	res = [
		object(co, lo, None, dn=dn, superordinate=superordinate, attributes=attrs)
		for dn, attrs in lo.search(filter_str, base, scope, [], unique, required, timeout, sizelimit)
	]
	return res

def identify(dn, attr):

def identify(dn, attr):
	return 'dhcpServer' in attr.get('objectClass', [])




import univention.admin.handlers
import univention.admin.localization

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/service'
operations = ['add', 'edit', 'remove', 'search']
childs = 1
usewizard = 1
short_description = _('DHCP: Service')
long_description = ''

options = {
}

property_descriptions = {
	'service': univention.admin.property(
		short_description=_('Service name'),
		long_description='',
		syntax=univention.admin.syntax.string,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=False,
		identifies=True
	),
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			'service',
		]),
	]),
]

mapping = univention.admin.mapping.mapping()
mapping.register('service', 'cn', None, univention.admin.mapping.ListToString)

from .__common import add_dhcp_options, DhcpOptions
add_dhcp_options(__name__)
add_dhcp_options( property_descriptions, mapping, layout )

class object(univention.admin.handlers.simpleLdap):
	module=module

class object(DhcpOptions):
	module = module
		global property_descriptions

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)

	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('service'),
			mapping.mapValue('service', self.info['service']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'univentionDhcpService']),
		]

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.conjunction('|', [
				univention.admin.filter.expression('objectClass', 'dhcpService'),
				univention.admin.filter.expression('objectClass', 'univentionDhcpService')
			])
	filter=univention.admin.filter.conjunction('&', [
		univention.admin.filter.conjunction('|', [
			univention.admin.filter.expression('objectClass', 'dhcpService'),
			univention.admin.filter.expression('objectClass', 'univentionDhcpService')
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj


lookup_filter = object.lookup_filter
lookup = object.lookup
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

	res=[]
	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
		res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
	return res

def identify(dn, attr):
	return bool(set(('dhcpService', 'univentionDhcpService')) & set(attr.get('objectClass', [])))
		or 'univentionDhcpService' in attr.get('objectClass', [])




import univention.admin.ipaddress
import univention.admin.localization

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/shared'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/service'
childs = 1
short_description = _('DHCP: Shared network')
long_description = ''

options = {
}

property_descriptions = {
	'name': univention.admin.property(
		short_description=_('Shared network name'),
		long_description='',
		syntax=univention.admin.syntax.uid,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=False,
		identifies=True
	)
}
options={
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			'name'
		]),
	]),
]

mapping = univention.admin.mapping.mapping()
mapping.register('name', 'cn', None, univention.admin.mapping.ListToString)

from .__common import add_dhcp_options, DhcpOptions
add_dhcp_options(__name__)


class object(DhcpOptions):
	module = module
		global property_descriptions

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)
	def open(self):
		univention.admin.handlers.simpleLdap.open(self)

		self.save()

	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('name'),
			mapping.mapValue('name', self.info['name']),
			self.position.getDn(),
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'dhcpSharedNetwork'])
		]

def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.expression('objectClass', 'dhcpSharedNetwork')
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj

	if filter_s:
		filter_p=univention.admin.filter.parse(filter_s)
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

lookup_filter = object.lookup_filter
lookup = object.lookup

	return res

def identify(dn, attr):
	
	return 'dhcpSharedNetwork' in attr.get('objectClass', [])





# /usr/share/common-licenses/AGPL-3; if not, see
# <http://www.gnu.org/licenses/>.

import string

from univention.admin.layout import Tab, Group
import univention.admin.filter
import univention.admin.handlers
import univention.admin.ipaddress
import univention.admin.localization

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/sharedsubnet'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/shared'
childs = 1
short_description = _('DHCP: Shared subnet')
long_description = ''

options = {
operations=['add','edit','remove','search']
superordinate='dhcp/shared'
childs=1
short_description=_('DHCP: Shared subnet')
long_description=''
options={
}

property_descriptions = {
	'subnet': univention.admin.property(
		short_description=_('Subnet address'),
		long_description='',
		syntax=univention.admin.syntax.ipv4Address,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=False,
		identifies=True
	),
	'subnetmask': univention.admin.property(
		short_description=_('Netmask'),
		long_description='',
		syntax=univention.admin.syntax.v4netmask,
		multivalue=False,
		options=[],
		required=True,
		may_change=True,
		identifies=False
	),
	'broadcastaddress': univention.admin.property(
		short_description=_('Broadcast address'),
		long_description='',
		syntax=univention.admin.syntax.ipv4Address,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
	'range': univention.admin.property(
		short_description=_('Dynamic address assignment'),
		long_description=_('Define a pool of addresses available for dynamic address assignment.'),
		syntax=univention.admin.syntax.IPv4_AddressRange,
		multivalue=True,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
}

options={
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			['subnet', 'subnetmask'],
			'broadcastaddress',
			'range'
		]),
	]),
]

def rangeMap( value ):
	return map( lambda x: ' '.join( x ), value ) or None

from .__common import rangeMap, rangeUnmap, add_dhcp_options, DhcpOptions
	return map( lambda x: x.split( ' ' ), value )

mapping = univention.admin.mapping.mapping()
mapping.register('subnet', 'cn', None, univention.admin.mapping.ListToString)
mapping.register('range', 'dhcpRange', rangeMap, rangeUnmap)
mapping.register('subnetmask', 'dhcpNetMask', None, univention.admin.mapping.ListToString)
mapping.register('broadcastaddress', 'univentionDhcpBroadcastAddress', None, univention.admin.mapping.ListToString)

add_dhcp_options(__name__)

add_dhcp_options( property_descriptions, mapping, layout )

class object(univention.admin.handlers.simpleLdap):
	module=module

class object(DhcpOptions):
	module = module
		global property_descriptions

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.superordinate = superordinate
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)

	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('subnet'),
			mapping.mapValue('subnet', self.info['subnet']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'univentionDhcpSubnet', 'univentionDhcpSharedSubnet']),
		]

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.expression('objectClass', 'univentionDhcpSubnet'),
			univention.admin.filter.expression('objectClass', 'univentionDhcpSharedSubnet')
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj

	filter=univention.admin.filter.conjunction('&', [
	univention.admin.filter.expression('objectClass', 'univentionDhcpSubnet'),
	univention.admin.filter.expression('objectClass', 'univentionDhcpSharedSubnet')
	])

lookup_filter = object.lookup_filter
lookup = object.lookup
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

	res=[]
	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
		res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
	return res

def identify(dn, attr):
	return set(('univentionDhcpSubnet', 'univentionDhcpSharedSubnet')) <= set(attr.get('objectClass', []))




# /usr/share/common-licenses/AGPL-3; if not, see
# <http://www.gnu.org/licenses/>.

import string

from univention.admin.layout import Tab, Group
import univention.admin.filter
import univention.admin.handlers
import univention.admin.ipaddress
import univention.admin.localization

translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
_ = translation.translate

module = 'dhcp/subnet'
operations = ['add', 'edit', 'remove', 'search']
superordinate = 'dhcp/service'
childs = 1
usewizard = 1
short_description = _('DHCP: Subnet')
long_description = ''

options = {
}

property_descriptions = {
	'subnet': univention.admin.property(
		short_description=_('Subnet address'),
		long_description='',
		syntax=univention.admin.syntax.ipv4Address,
		multivalue=False,
		include_in_default_search=True,
		options=[],
		required=True,
		may_change=False,
		identifies=True
	),
	'subnetmask': univention.admin.property(
		short_description=_('Netmask'),
		long_description='',
		syntax=univention.admin.syntax.v4netmask,
		multivalue=False,
		options=[],
		required=True,
		may_change=True,
		identifies=False
	),
	'broadcastaddress': univention.admin.property(
		short_description=_('Broadcast address'),
		long_description='',
		syntax=univention.admin.syntax.ipv4Address,
		multivalue=False,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
	'range': univention.admin.property(
		short_description=_('Dynamic address assignment'),
		long_description=_('Define a pool of addresses available for dynamic address assignment.'),
		syntax=univention.admin.syntax.IPv4_AddressRange,
		multivalue=True,
		options=[],
		required=False,
		may_change=True,
		identifies=False
	),
}

options={
}

layout = [
	Tab(_('General'), _('Basic settings'), layout=[
		Group(_('General'), layout=[
			['subnet', 'subnetmask'],
			'broadcastaddress',
			'range'
		]),
	]),
]

from .__common import rangeUnmap, add_dhcp_options, DhcpOptions
	return map( lambda x: ' '.join( x ), value )

mapping = univention.admin.mapping.mapping()
	return map( lambda x: x.split(), value )

mapping=univention.admin.mapping.mapping()
mapping.register('subnet', 'cn', None, univention.admin.mapping.ListToString)
mapping.register('subnetmask', 'dhcpNetMask', None, univention.admin.mapping.ListToString)
mapping.register('broadcastaddress', 'univentionDhcpBroadcastAddress', None, univention.admin.mapping.ListToString)

add_dhcp_options(__name__)

add_dhcp_options( property_descriptions, mapping, layout )

class object(univention.admin.handlers.simpleLdap):
	module=module

class object(DhcpOptions):
	module = module
		global property_descriptions

	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		self.superordinate = superordinate
		self.mapping = mapping
		self.descriptions = property_descriptions

		if not superordinate:
			raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
		if not dn and not position:
			raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'

		super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		self.setup_options(options)

	def open(self):
		super(object, self).open()
		self.info['range'] = self.oldinfo['range'] = rangeUnmap(self.oldattr.get('dhcpRange', []))
		self.oldinfo['range'] = rangeUnmap( self.oldattr.get('dhcpRange', []) )


	def _ldap_pre_create(self):
		self.dn = '%s=%s,%s' % (
			mapping.mapName('subnet'),
			mapping.mapValue('subnet', self.info['subnet']),
			self.position.getDn()
		)

	def _ldap_addlist(self):
		return [
			('objectClass', ['top', 'univentionDhcpSubnet']),
		]

	def _ldap_modlist(self):
		ml = super(object, self)._ldap_modlist()
		ml=univention.admin.handlers.simpleLdap._ldap_modlist(self)

		if self.hasChanged('range'):
			dhcpRange = []
			for i in self['range']:
				for j in self['range']:
					if i != j and univention.admin.ipaddress.is_range_overlapping(i, j):
						raise univention.admin.uexceptions.rangesOverlapping, '%s-%s; %s-%s' % (i[0], i[1], j[0], j[1])

				ip_in_network = True
				for j in i:
					if not univention.admin.ipaddress.ip_is_in_network(self['subnet'], self['subnetmask'], j):
						ip_in_network = False

					if univention.admin.ipaddress.ip_is_network_address(self['subnet'], self['subnetmask'], j):
						raise univention.admin.uexceptions.rangeInNetworkAddress, '%s-%s' % (i[0], i[1])

						raise univention.admin.uexceptions.rangeInBroadcastAddress, '%s-%s' % (i[0], i[1])

				if ip_in_network:
					dhcpRange.append(' '.join(i))
				else:
					raise univention.admin.uexceptions.rangeNotInNetwork, '%s-%s' % (i[0], i[1])
			#univention.debug.debug(univention.debug.ADMIN, univention.debug.ERROR, 'old Range: %s' % self.oldinfo['range'])
			if '' in dhcpRange:
				dhcpRange.remove('')
			ml.append(('dhcpRange', self.oldattr.get('dhcpRange', []), dhcpRange))
		return add_dhcp_objectclass( self, ml )

		return ml

	@staticmethod
	def lookup_filter(filter_s=None, lo=None):
		filter_obj = univention.admin.filter.conjunction('&', [
			univention.admin.filter.expression('objectClass', 'univentionDhcpSubnet'),
			univention.admin.filter.conjunction('!', [univention.admin.filter.expression('objectClass', 'univentionDhcpSharedSubnet')])
		])
		filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		return filter_obj

	filter=univention.admin.filter.conjunction('&', [
	univention.admin.filter.expression('objectClass', 'univentionDhcpSubnet'),
	univention.admin.filter.conjunction('!', [univention.admin.filter.expression('objectClass', 'univentionDhcpSharedSubnet')])
	])

lookup_filter = object.lookup_filter
lookup = object.lookup
		univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
		filter.expressions.append(filter_p)

	res=[]
	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
		res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
	return res

def identify(dn, attr):
	ocs = set(attr.get('objectClass', []))
	return 'univentionDhcpSubnet' in ocs and not 'univentionDhcpSharedSubnet' in ocs

Return to bug 33223

Lines 30-84 Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/__common.py (-34 / +94 lines)
30	# /usr/share/common-licenses/AGPL-3; if not, see	30	# /usr/share/common-licenses/AGPL-3; if not, see
31	# <http://www.gnu.org/licenses/>.	31	# <http://www.gnu.org/licenses/>.
32		32
33	import copy	33	import sys
34
35	import univention.admin.localization	34	import univention.admin.localization
36	from univention.admin.layout import Tab, Group	35	from univention.admin.layout import Tab
		36	from univention.admin.handlers import simpleLdap
37		37
38	translation = univention.admin.localization.translation( 'univention.admin.handlers.dhcp' )	38	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
39	_ = translation.translate	39	_ = translation.translate
40		40
		41
		42	_options = {
		43	'options': univention.admin.option(
		44	short_description=_('Allow custom DHCP options'),
		45	long_description=_("Allow adding custom DHCP options. Experts only!"),
		46	default=False,
		47	editable=True,
		48	objectClasses=['dhcpOptions'],
		49	),
		50	}
		51
		52
41	_properties = {	53	_properties = {
42	'option': univention.admin.property(	54	'option': univention.admin.property(
43	short_description = _( 'DHCP options' ),	55	short_description=_('DHCP options'),
44	long_description = _( 'Defines DHCP options for the subnet.' ),	56	long_description=_('Defines additional DHCP options.'),
45	syntax = univention.admin.syntax.string,	57	syntax=univention.admin.syntax.string,
46	multivalue = True,	58	multivalue=True,
47	options = [],	59	options=["options"],
48	required = 0,	60	required=False,
49	may_change = True,	61	may_change=True,
50	identifies = 0	62	identifies=False,
51	),	63	),
52	}	64	}
53		65
54	# def optionMap( value ):
55	# return map( lambda x: ' '.join( x ), value )
56		66
57	# def optionUnmap( value ):	67	def rangeMap(value):
58	# return map( lambda x: x.split( ' ', 1 ), value )	68	return map(lambda x: ' '.join(x), value)
		69
		70
		71	def rangeUnmap(value):
		72	return map(lambda x: x.split(), value)
		73
59		74
60	_mappings = (	75	_mappings = (
61	# ( 'option', 'dhcpOption', optionMap, optionUnmap ),	76	('option', 'dhcpOption', None, None),
62	( 'option', 'dhcpOption', None, univention.admin.mapping.ListToString ),	77	)
63	)	78
64		79
65	def add_dhcp_options( properties, mapping, layout ):	80	def add_dhcp_options(module_name):
66	global _properties, _mappings	81	module = sys.modules[module_name]
67		82
68	for name, prop in _properties.items():	83	options = getattr(module, "options")
69	properties[ name ] = prop	84	options.update(_options)
70		85
		86	properties = getattr(module, "property_descriptions")
		87	properties.update(_properties)
		88
		89	mapping = getattr(module, "mapping")
71	for item in _mappings:	90	for item in _mappings:
72	mapping.register( *item )	91	mapping.register(*item)
		92
		93	layout = getattr(module, "layout")
		94	layout.append(Tab(
		95	_('DHCP options'),
		96	_('Custom DHCP options'),
		97	advanced=True,
		98	layout=['option']
		99	))
		100
		101
		102	class SimpleDhcp(simpleLdap):
		103	@classmethod
		104	def lookup(cls, co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
		105	filter_str = unicode(cls.lookup_filter(filter_s))
		106	res = [
		107	cls(co, lo, None, dn=dn, superordinate=superordinate, attributes=attrs)
		108	for dn, attrs in lo.search(filter_str, base, scope, [], unique, required, timeout, sizelimit)
		109	]
		110	return res
		111
		112
		113	class DhcpOptions(SimpleDhcp):
		114	def setup_options(self, options):
		115	self.options = []
		116	self._define_options(options)
		117
		118	def open(self):
		119	super(DhcpOptions, self).open()
		120	try:
		121	ocs = self.oldattr['objectClass']
		122	if "dhcpOptions" in ocs:
		123	self.options.append("options")
		124	except LookupError:
		125	pass
		126	self.old_options = list(self.options)
		127
		128	def _ldap_modlist(self):
		129	if "options" not in self.options:
		130	del self.info.get('option', [])[:]
73		131
74	# currently not visible	132	mod_list = super(DhcpOptions, self)._ldap_modlist()
75	#layout.append( Tab( _( 'Advanced' ), _( 'Advanced DHCP options' ), layout = [ 'option' ] ) )
76		133
77	def add_dhcp_objectclass( self, ml ):	134	old_ocs = self.oldattr.get('objectClass', [])
78	oldOCs = self.oldattr.get( 'objectClass', [] )	135	if self.info.get('option', []):
79	newOCs = copy.copy( oldOCs )	136	if 'dhcpOptions' not in old_ocs:
80	if self.info.get( 'option', [] ) and not 'dhcpOptions' in oldOCs:	137	new_ocs = old_ocs + ['dhcpOptions']
81	newOCs.append( 'dhcpOptions' )	138	mod_list.append(('objectClass', old_ocs, new_ocs))
82	ml.append( ( 'objectClass', oldOCs, newOCs ) )	139	elif "options" not in self.options and 'dhcpOptions' in old_ocs:
		140	new_ocs = list(old_ocs)
		141	new_ocs.remove("dhcpOptions")
		142	mod_list.append(('objectClass', old_ocs, new_ocs))
83		143
84	return ml	144	return mod_list

Lines 44-121 import univention.admin.handlers.dhcp.sharedsubnet Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/dhcp.py (-55 / +64 lines)
44	import univention.admin.handlers.dhcp.subnet	44	import univention.admin.handlers.dhcp.subnet
45		45
46		46
47	translation=univention.admin.localization.translation('univention.admin.handlers.dhcp')	47	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
48	_=translation.translate	48	_ = translation.translate
49		49
50		50
51	module='dhcp/dhcp'	51	module = 'dhcp/dhcp'
52		52
53	childs=0	53	childs = 0
54	short_description=_('DHCP')	54	short_description = _('DHCP')
55	long_description=''	55	long_description = ''
56	operations=['search']	56	operations = ['search']
57	usewizard=1	57	usewizard = 1
58	wizardmenustring=_("DHCP")	58	wizardmenustring = _("DHCP")
59	wizarddescription=_("Add, edit and delete DHCP objects")	59	wizarddescription = _("Add, edit and delete DHCP objects")
60	wizardoperations={"add":[_("Add"), _("Add DHCP object")],"find":[_("Search"), _("Search DHCP object(s)")]}	60	wizardoperations = {
61	wizardpath="univentionDhcpObject"	61	"add": [_("Add"), _("Add DHCP object")],
62	wizardsuperordinates = ( 'None', 'dhcp/service', 'dhcp/shared' )	62	"find": [_("Search"), _("Search DHCP object(s)")],
		63	}
		64	wizardpath = "univentionDhcpObject"
		65	wizardsuperordinates = ('None', 'dhcp/service', 'dhcp/shared')
63	wizardtypesforsuper = {	66	wizardtypesforsuper = {
64	'None' : ( 'dhcp/service', ),	67	'None': ('dhcp/service',),
65	'dhcp/service' : ( 'dhcp/host', 'dhcp/server', 'dhcp/shared', 'dhcp/subnet' ),	68	'dhcp/service': ('dhcp/host', 'dhcp/server', 'dhcp/shared', 'dhcp/subnet'),
66	'dhcp/shared' : ( 'dhcp/sharedsubnet', )	69	'dhcp/shared': ('dhcp/sharedsubnet',)
67	}	70	}
68		71
69	childmodules=["dhcp/host","dhcp/pool","dhcp/server","dhcp/service","dhcp/shared","dhcp/sharedsubnet","dhcp/subnet"]	72	childmodules = [
70	virtual=1	73	"dhcp/host",
71	options={	74	"dhcp/pool",
		75	"dhcp/server",
		76	"dhcp/service",
		77	"dhcp/shared",
		78	"dhcp/sharedsubnet",
		79	"dhcp/subnet",
		80	]
		81	virtual = 1
		82
		83	options = {
72	}	84	}
73	property_descriptions={	85
		86	property_descriptions = {
74	'name': univention.admin.property(	87	'name': univention.admin.property(
75	short_description=_('Name'),	88	short_description=_('Name'),
76	long_description='',	89	long_description='',
77	syntax=univention.admin.syntax.string,	90	syntax=univention.admin.syntax.string,
78	multivalue=0,	91	multivalue=False,
79	include_in_default_search=1,	92	include_in_default_search=True,
80	options=[],	93	options=[],
81	required=1,	94	required=True,
82	may_change=1,	95	may_change=True,
83	identifies=1	96	identifies=True
84	)	97	)
85	}	98	}
86		99
87	layout = [ Tab( _( 'General' ), _( 'Basic settings' ), layout = [ "name" ] ) ]	100	layout = [Tab(_('General'), _('Basic settings'), layout=["name"])]
88		101
89	mapping=univention.admin.mapping.mapping()	102	mapping = univention.admin.mapping.mapping()
90		103
91		104
92	class object(univention.admin.handlers.simpleLdap):	105	class object(univention.admin.handlers.simpleLdap):
93	module=module	106	module = module
94		107
95	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):	108	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
96	global mapping	109	self.mapping = mapping
97	global property_descriptions	110	self.descriptions = property_descriptions
98		111
99	self.mapping=mapping	112	super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
100	self.descriptions=property_descriptions
101
102	univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )
103		113
104		114
105	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):	115	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
106	ret=[]	116	ret = []
107	if superordinate:	117	if superordinate:
108	ret+= univention.admin.handlers.dhcp.host.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	118	ret += univention.admin.handlers.dhcp.host.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
109	ret+= univention.admin.handlers.dhcp.pool.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	119	ret += univention.admin.handlers.dhcp.pool.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
110	ret+=univention.admin.handlers.dhcp.server.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	120	ret += univention.admin.handlers.dhcp.server.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
111	ret+= univention.admin.handlers.dhcp.shared.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	121	ret += univention.admin.handlers.dhcp.shared.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
112	ret+= univention.admin.handlers.dhcp.sharedsubnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	122	ret += univention.admin.handlers.dhcp.sharedsubnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
113	ret+= univention.admin.handlers.dhcp.subnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	123	ret += univention.admin.handlers.dhcp.subnet.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
114	else:	124	else:
115	ret+= univention.admin.handlers.dhcp.service.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)	125	ret += univention.admin.handlers.dhcp.service.lookup(co, lo, filter_s, base, superordinate, scope, unique, required, timeout, sizelimit)
116	return ret	126	return ret
117		127
		128
118	def identify(dn, attr, canonical=0):	129	def identify(dn, attr, canonical=0):
119	pass	130	pass
120
121

Lines 34-160 from univention.admin.layout import Tab, Group Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/host.py (-75 / +85 lines)
34	import univention.admin.filter	34	import univention.admin.filter
35	import univention.admin.handlers	35	import univention.admin.handlers
36	import univention.admin.localization	36	import univention.admin.localization
37	import univention.debug	37	import univention.debug as ud
38		38
39	translation=univention.admin.localization.translation('univention.admin.handlers.dhcp')	39	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
40	_=translation.translate	40	_ = translation.translate
41		41
42	module='dhcp/host'	42	module = 'dhcp/host'
43	operations=['add','edit','remove','search']	43	operations = ['add', 'edit', 'remove', 'search']
44	superordinate='dhcp/service'	44	superordinate = 'dhcp/service'
45	childs=0	45	childs = 0
46	usewizard=1	46	usewizard = 1
47	short_description=_('DHCP: Host')	47	short_description = _('DHCP: Host')
48	long_description=''	48	long_description = ''
49	options={	49
		50	options = {
50	}	51	}
51	property_descriptions={	52
		53	property_descriptions = {
52	'host': univention.admin.property(	54	'host': univention.admin.property(
53	short_description=_('Hostname'),	55	short_description=_('Hostname'),
54	long_description='',	56	long_description='',
55	syntax=univention.admin.syntax.string,	57	syntax=univention.admin.syntax.string,
56	multivalue=0,	58	multivalue=False,
57	include_in_default_search=1,	59	include_in_default_search=True,
58	options=[],	60	options=[],
59	required=1,	61	required=True,
60	may_change=1,	62	may_change=True,
61	identifies=1	63	identifies=True
62	),	64	),
63	'hwaddress': univention.admin.property(	65	'hwaddress': univention.admin.property(
64	short_description=_('Hardware address'),	66	short_description=_('Hardware address'),
65	long_description=_('Currently, only the ethernet and token-ring types are recognized. \	67	long_description=_(
66	The hardware-address should be a set of hexadecimal octets (numbers from 0 through ff) separated by colons.'),	68	'Currently, only the ethernet and token-ring types are recognized.'
67	syntax=univention.admin.syntax.DHCP_HardwareAddress,	69	'The hardware-address should be a set of hexadecimal octets (numbers from 0 through ff) separated by colons.'),
68	multivalue=0,	70	syntax=univention.admin.syntax.DHCP_HardwareAddress,
69	options=[],	71	multivalue=False,
70	required=1,	72	options=[],
71	may_change=1,	73	required=True,
72	identifies=0	74	may_change=True,
73	),	75	identifies=False
		76	),
74	'fixedaddress': univention.admin.property(	77	'fixedaddress': univention.admin.property(
75	short_description=_('Fixed IP addresses'),	78	short_description=_('Fixed IP addresses'),
76	long_description=_('Assign one or more fixed IP addresses. \	79	long_description=_(
77	Each address should be either an IP address or a domain name that resolves to one or more IP addresses'),	80	'Assign one or more fixed IP addresses.'
78	syntax=univention.admin.syntax.string,	81	'Each address should be either an IP address or a domain name that resolves to one or more IP addresses'),
79	multivalue=1,	82	syntax=univention.admin.syntax.string,
80	options=[],	83	multivalue=True,
81	required=0,	84	options=[],
82	may_change=1,	85	required=False,
83	identifies=0	86	may_change=True,
84	),	87	identifies=False
		88	),
85	}	89	}
86	layout=[	90
87	Tab( _('General'), _('Basic settings'), layout = [	91	layout = [
88	Group( _( 'General' ), layout = [	92	Tab(_('General'), _('Basic settings'), layout=[
		93	Group(_('General'), layout=[
89	'host',	94	'host',
90	'hwaddress',	95	'hwaddress',
91	'fixedaddress'	96	'fixedaddress'
92	] ),	97	]),
93	] )	98	])
94	]	99	]
95		100
		101
96	def unmapHWAddress(old):	102	def unmapHWAddress(old):
97	univention.debug.debug(univention.debug.ADMIN, univention.debug.INFO, 'host.py: unmapHWAddress: old: %s' % old)	103	ud.debug(ud.ADMIN, ud.INFO, 'host.py: unmapHWAddress: old: %s' % old)
98	if not old:	104	if not old:
99	return ['', '']	105	return ['', '']
100	return old[0].split(' ')	106	return old[0].split(' ')
101		107
		108
102	def mapHWAddress(old):	109	def mapHWAddress(old):
103	univention.debug.debug(univention.debug.ADMIN, univention.debug.INFO, 'host.py: mapHWAddress: old: %s' % old)	110	ud.debug(ud.ADMIN, ud.INFO, 'host.py: mapHWAddress: old: %s' % old)
104	if not old[0]:	111	if not old[0]:
105	return ''	112	return ''
106	else:	113	else:
107	if len (old) > 1:	114	if len(old) > 1:
108	return '%s %s' % (old[0], old[1])	115	return '%s %s' % (old[0], old[1])
109	else:	116	else:
110	return old	117	return old
111		118
112	mapping=univention.admin.mapping.mapping()	119
		120	mapping = univention.admin.mapping.mapping()
113	mapping.register('host', 'cn', None, univention.admin.mapping.ListToString)	121	mapping.register('host', 'cn', None, univention.admin.mapping.ListToString)
114	mapping.register('hwaddress', 'dhcpHWAddress', mapHWAddress, unmapHWAddress)	122	mapping.register('hwaddress', 'dhcpHWAddress', mapHWAddress, unmapHWAddress)
115	mapping.register('fixedaddress', 'univentionDhcpFixedAddress')	123	mapping.register('fixedaddress', 'univentionDhcpFixedAddress')
116		124
117	class object(univention.admin.handlers.simpleLdap):	125	from .__common import add_dhcp_options, DhcpOptions
118	module=module	126	add_dhcp_options(__name__)
119		127
120	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
121	global mapping
122	global property_descriptions
123		128
124	self.mapping=mapping	129	class object(DhcpOptions):
125	self.descriptions=property_descriptions	130	module = module
		131
		132	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
		133	self.mapping = mapping
		134	self.descriptions = property_descriptions
126		135
127	if not superordinate:	136	if not superordinate:
128	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'	137	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
129	if not dn and not position:	138	if not dn and not position:
130	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'	139	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'
131		140
132	univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )	141	super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		142	self.setup_options(options)
133		143
134	def _ldap_pre_create(self):	144	def _ldap_pre_create(self):
135	self.dn='%s=%s,%s' % (mapping.mapName('host'), mapping.mapValue('host', self.info['host']), self.position.getDn())	145	self.dn = '%s=%s,%s' % (
		146	mapping.mapName('host'),
		147	mapping.mapValue('host', self.info['host']),
		148	self.position.getDn()
		149	)
136		150
137	def _ldap_addlist(self):	151	def _ldap_addlist(self):
138	return [	152	return [
139	('objectClass', ['top', 'univentionDhcpHost']),	153	('objectClass', ['top', 'univentionDhcpHost']),
140	]	154	]
141		155
142	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):	156	@staticmethod
		157	def lookup_filter(filter_s=None, lo=None):
		158	filter_obj = univention.admin.filter.conjunction('&', [
		159	univention.admin.filter.expression('objectClass', 'univentionDhcpHost')
		160	])
		161	filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		162	return filter_obj
143		163
144	filter=univention.admin.filter.conjunction('&', [
145	univention.admin.filter.expression('objectClass', 'univentionDhcpHost')
146	])
147		164
148	if filter_s:	165	lookup_filter = object.lookup_filter
149	filter_p=univention.admin.filter.parse(filter_s)	166	lookup = object.lookup
150	univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
151	filter.expressions.append(filter_p)
152		167
153	res=[]
154	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
155	res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
156	return res
157		168
158	def identify(dn, attr):	169	def identify(dn, attr):
159
160	return 'univentionDhcpHost' in attr.get('objectClass', [])	170	return 'univentionDhcpHost' in attr.get('objectClass', [])

Lines 35-105 import univention.admin.filter Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/server.py (-56 / +61 lines)
35	import univention.admin.handlers	35	import univention.admin.handlers
36	import univention.admin.localization	36	import univention.admin.localization
37		37
38	translation=univention.admin.localization.translation('univention.admin.handlers.dhcp')	38	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
39	_=translation.translate	39	_ = translation.translate
40		40
41	module='dhcp/server'	41	module = 'dhcp/server'
42	operations=['add','edit','remove','search']	42	operations = ['add', 'edit', 'remove', 'search']
43	superordinate='dhcp/service'	43	superordinate = 'dhcp/service'
44	childs=0	44	childs = 0
45	usewizard=1	45	usewizard = 1
46	short_description=_('DHCP: Server')	46	short_description = _('DHCP: Server')
47	long_description=''	47	long_description = ''
48	options={	48
		49	options = {
49	}	50	}
50		51
51	property_descriptions={	52	property_descriptions = {
52	'server': univention.admin.property(	53	'server': univention.admin.property(
53	short_description=_('Server name'),	54	short_description=_('Server name'),
54	long_description='',	55	long_description='',
55	syntax=univention.admin.syntax.string,	56	syntax=univention.admin.syntax.string,
56	multivalue=0,	57	multivalue=False,
57	include_in_default_search=1,	58	include_in_default_search=True,
58	options=[],	59	options=[],
59	required=1,	60	required=True,
60	may_change=1,	61	may_change=True,
61	identifies=1	62	identifies=True
62	),	63	),
63	}	64	}
64		65
65	layout = [	66	layout = [
66	Tab( _( 'General' ), _('General settings'), layout = [	67	Tab(_('General'), _('General settings'), layout=[
67	Group( _( 'General' ), layout = [	68	Group(_('General'), layout=[
68	'server'	69	'server'
69	] ),	70	]),
70	] )	71	])
71	]	72	]
72		73
73	mapping=univention.admin.mapping.mapping()	74	mapping = univention.admin.mapping.mapping()
74	mapping.register('server', 'cn', None, univention.admin.mapping.ListToString)	75	mapping.register('server', 'cn', None, univention.admin.mapping.ListToString)
75		76
76	from .__common import add_dhcp_options	77	from .__common import add_dhcp_options
		78	add_dhcp_options(__name__)
77		79
78	add_dhcp_options( property_descriptions, mapping, layout )
79		80
80	class object(univention.admin.handlers.simpleLdap):	81	class object(univention.admin.handlers.simpleLdap):
81	module=module	82	module = module
82
83	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):
84	global mapping
85	global property_descriptions
86		83
87	self.superordinate=superordinate	84	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
88	self.mapping=mapping	85	self.superordinate = superordinate
89	self.descriptions=property_descriptions	86	self.mapping = mapping
		87	self.descriptions = property_descriptions
90		88
91	if not superordinate:	89	if not superordinate:
92	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'	90	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
93	if not dn and not position:	91	if not dn and not position:
94	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'	92	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'
95		93
96	univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )	94	super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
97		95
98	def _ldap_pre_create(self):	96	def _ldap_pre_create(self):
99	self.dn='%s=%s,%s' % (mapping.mapName('server'), mapping.mapValue('server', self.info['server']), self.position.getDn())	97	self.dn = '%s=%s,%s' % (
		98	mapping.mapName('server'),
		99	mapping.mapValue('server', self.info['server']),
		100	self.position.getDn()
		101	)
100		102
101	def _ldap_addlist(self):	103	def _ldap_addlist(self):
102	searchBase=self.position.getDomain()	104	searchBase = self.position.getDomain()
103	if self.lo.searchDn(base=searchBase, filter='(&(objectClass=dhcpServer)(cn=%s))' % (self.info['server'])):	105	if self.lo.searchDn(base=searchBase, filter='(&(objectClass=dhcpServer)(cn=%s))' % (self.info['server'])):
104	raise univention.admin.uexceptions.dhcpServerAlreadyUsed, self.info['server']	106	raise univention.admin.uexceptions.dhcpServerAlreadyUsed, self.info['server']
105		107
Lines 107-139 class object(univention.admin.handlers.simpleLdap): Link Here
107	('objectClass', ['top', 'dhcpServer']),	109	('objectClass', ['top', 'dhcpServer']),
108	('dhcpServiceDN', self.superordinate.dn),	110	('dhcpServiceDN', self.superordinate.dn),
109	]	111	]
		112
110	def _ldap_post_move(self, olddn):	113	def _ldap_post_move(self, olddn):
111	'''edit dhcpServiceDN'''	114	'''edit dhcpServiceDN'''
112	oldServiceDN=self.lo.getAttr(self.dn, 'dhcpServiceDN')	115	oldServiceDN = self.lo.getAttr(self.dn, 'dhcpServiceDN')
113	module=univention.admin.modules.identifyOne(self.position.getDn(), self.lo.get(self.position.getDn()))	116	module = univention.admin.modules.identifyOne(self.position.getDn(), self.lo.get(self.position.getDn()))
114	object=univention.admin.objects.get(module, None, self.lo, self.position, dn=self.position.getDn())	117	object = univention.admin.objects.get(module, None, self.lo, self.position, dn=self.position.getDn())
115	shadow_module, shadow_object=univention.admin.objects.shadow(self.lo, module, object, self.position)	118	shadow_module, shadow_object = univention.admin.objects.shadow(self.lo, module, object, self.position)
116	self.lo.modify(self.dn, [('dhcpServiceDN', oldServiceDN[0], shadow_object.dn)])	119	self.lo.modify(self.dn, [('dhcpServiceDN', oldServiceDN[0], shadow_object.dn)])
117		120
118	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
119		121
120	filter=univention.admin.filter.conjunction('&', [	122	def lookup_filter(filter_s=None, lo=None):
121	univention.admin.filter.expression('objectClass', 'dhcpServer')	123	filter_obj = univention.admin.filter.conjunction('&', [
		124	univention.admin.filter.expression('objectClass', 'dhcpServer')
122	])	125	])
		126	filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		127	return filter_obj
123		128
124	if superordinate:
125	filter.expressions.append(univention.admin.filter.expression('dhcpServiceDN', superordinate.dn))
126		129
127	if filter_s:	130	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
128	filter_p=univention.admin.filter.parse(filter_s)	131	filter_obj = lookup_filter(filter_s)
129	univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)	132	if superordinate:
130	filter.expressions.append(filter_p)	133	filter_obj.expressions.append(univention.admin.filter.expression('dhcpServiceDN', superordinate.dn))
		134	filter_str = unicode(filter_obj)
131		135
132	res=[]	136	res = [
133	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):	137	object(co, lo, None, dn=dn, superordinate=superordinate, attributes=attrs)
134	res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))	138	for dn, attrs in lo.search(filter_str, base, scope, [], unique, required, timeout, sizelimit)
		139	]
135	return res	140	return res
136		141
137	def identify(dn, attr):
138		142
		143	def identify(dn, attr):
139	return 'dhcpServer' in attr.get('objectClass', [])	144	return 'dhcpServer' in attr.get('objectClass', [])

Lines 35-127 import univention.admin.filter Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/service.py (-61 / +56 lines)
35	import univention.admin.handlers	35	import univention.admin.handlers
36	import univention.admin.localization	36	import univention.admin.localization
37		37
38	translation=univention.admin.localization.translation('univention.admin.handlers.dhcp')	38	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
39	_=translation.translate	39	_ = translation.translate
40		40
41	module='dhcp/service'	41	module = 'dhcp/service'
42	operations=['add','edit','remove','search']	42	operations = ['add', 'edit', 'remove', 'search']
43	childs=1	43	childs = 1
44	usewizard=1	44	usewizard = 1
45	short_description=_('DHCP: Service')	45	short_description = _('DHCP: Service')
46	long_description=''	46	long_description = ''
47	options={	47
		48	options = {
48	}	49	}
49	property_descriptions={	50
		51	property_descriptions = {
50	'service': univention.admin.property(	52	'service': univention.admin.property(
51	short_description=_('Service name'),	53	short_description=_('Service name'),
52	long_description='',	54	long_description='',
53	syntax=univention.admin.syntax.string,	55	syntax=univention.admin.syntax.string,
54	multivalue=0,	56	multivalue=False,
55	include_in_default_search=1,	57	include_in_default_search=True,
56	options=[],	58	options=[],
57	required=1,	59	required=True,
58	may_change=0,	60	may_change=False,
59	identifies=1	61	identifies=True
60	),	62	),
61	}	63	}
62		64
63	layout = [	65	layout = [
64	Tab( _( 'General' ), _( 'Basic settings' ), layout = [	66	Tab(_('General'), _('Basic settings'), layout=[
65	Group( _( 'General' ), layout = [	67	Group(_('General'), layout=[
66	'service',	68	'service',
67	] ),	69	]),
68	] ),	70	]),
69	]	71	]
70		72
71	mapping=univention.admin.mapping.mapping()	73	mapping = univention.admin.mapping.mapping()
72	mapping.register('service', 'cn', None, univention.admin.mapping.ListToString)	74	mapping.register('service', 'cn', None, univention.admin.mapping.ListToString)
73		75
74	from .__common import add_dhcp_options, add_dhcp_objectclass	76	from .__common import add_dhcp_options, DhcpOptions
75		77	add_dhcp_options(__name__)
76	add_dhcp_options( property_descriptions, mapping, layout )
77		78
78	class object(univention.admin.handlers.simpleLdap):
79	module=module
80		79
81	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):	80	class object(DhcpOptions):
82	global mapping	81	module = module
83	global property_descriptions
84		82
85	self.mapping=mapping	83	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
86	self.descriptions=property_descriptions	84	self.mapping = mapping
		85	self.descriptions = property_descriptions
87		86
88	if not dn and not position:	87	if not dn and not position:
89	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'	88	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'
90		89
91	univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )	90	super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
		91	self.setup_options(options)
92		92
93	def _ldap_pre_create(self):	93	def _ldap_pre_create(self):
94	self.dn='%s=%s,%s' % (mapping.mapName('service'), mapping.mapValue('service', self.info['service']), self.position.getDn())	94	self.dn = '%s=%s,%s' % (
		95	mapping.mapName('service'),
		96	mapping.mapValue('service', self.info['service']),
		97	self.position.getDn()
		98	)
95		99
96	def _ldap_addlist(self):	100	def _ldap_addlist(self):
97	return [	101	return [
98	('objectClass', [ 'top', 'univentionDhcpService', 'dhcpOptions' ] ),	102	('objectClass', ['top', 'univentionDhcpService']),
99	]	103	]
100		104
101	def _ldap_modlist(self):	105	@staticmethod
102	ml = univention.admin.handlers.simpleLdap._ldap_modlist( self )	106	def lookup_filter(filter_s=None, lo=None):
103		107	filter_obj = univention.admin.filter.conjunction('&', [
104	return add_dhcp_objectclass( self, ml )	108	univention.admin.filter.conjunction('\|', [
105		109	univention.admin.filter.expression('objectClass', 'dhcpService'),
106	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):	110	univention.admin.filter.expression('objectClass', 'univentionDhcpService')
107		111	])
108	filter=univention.admin.filter.conjunction('&', [
109	univention.admin.filter.conjunction('\|', [
110	univention.admin.filter.expression('objectClass', 'dhcpService'),
111	univention.admin.filter.expression('objectClass', 'univentionDhcpService')
112	])	112	])
113	])	113	filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		114	return filter_obj
		115
114		116
115	if filter_s:	117	lookup_filter = object.lookup_filter
116	filter_p=univention.admin.filter.parse(filter_s)	118	lookup = object.lookup
117	univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
118	filter.expressions.append(filter_p)
119		119
120	res=[]
121	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):
122	res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))
123	return res
124		120
125	def identify(dn, attr):	121	def identify(dn, attr):
126	return 'dhcpService' in attr.get('objectClass', []) \	122	return bool(set(('dhcpService', 'univentionDhcpService')) & set(attr.get('objectClass', [])))
127	or 'univentionDhcpService' in attr.get('objectClass', [])

Lines 36-126 import univention.admin.handlers Link Here

(-)a/branches/ucs-3.2/ucs-3.2-0/management/univention-directory-manager-modules/modules/univention/admin/handlers/dhcp/shared.py (-56 / +53 lines)
36	import univention.admin.ipaddress	36	import univention.admin.ipaddress
37	import univention.admin.localization	37	import univention.admin.localization
38		38
39	translation=univention.admin.localization.translation('univention.admin.handlers.dhcp')	39	translation = univention.admin.localization.translation('univention.admin.handlers.dhcp')
40	_=translation.translate	40	_ = translation.translate
41		41
42	module='dhcp/shared'	42	module = 'dhcp/shared'
43	operations=['add','edit','remove','search']	43	operations = ['add', 'edit', 'remove', 'search']
44	superordinate='dhcp/service'	44	superordinate = 'dhcp/service'
45	childs=1	45	childs = 1
46	short_description=_('DHCP: Shared network')	46	short_description = _('DHCP: Shared network')
47	long_description=''	47	long_description = ''
48	options={	48
		49	options = {
49	}	50	}
50	property_descriptions={	51
		52	property_descriptions = {
51	'name': univention.admin.property(	53	'name': univention.admin.property(
52	short_description=_('Shared network name'),	54	short_description=_('Shared network name'),
53	long_description='',	55	long_description='',
54	syntax=univention.admin.syntax.uid,	56	syntax=univention.admin.syntax.uid,
55	multivalue=0,	57	multivalue=False,
56	include_in_default_search=1,	58	include_in_default_search=True,
57	options=[],	59	options=[],
58	required=1,	60	required=True,
59	may_change=0,	61	may_change=False,
60	identifies=1	62	identifies=True
61	)	63	)
62	}
63	options={
64	}	64	}
65		65
66	layout = [	66	layout = [
67	Tab( _( 'General' ), _( 'Basic settings' ), layout = [	67	Tab(_('General'), _('Basic settings'), layout=[
68	Group( _( 'General' ), layout = [	68	Group(_('General'), layout=[
69	'name'	69	'name'
70	] ),	70	]),
71	] ),	71	]),
72	]	72	]
73		73
74	mapping=univention.admin.mapping.mapping()	74	mapping = univention.admin.mapping.mapping()
75	mapping.register('name', 'cn', None, univention.admin.mapping.ListToString)	75	mapping.register('name', 'cn', None, univention.admin.mapping.ListToString)
76		76
77	class object(univention.admin.handlers.simpleLdap):	77	from .__common import add_dhcp_options, DhcpOptions
78	module=module	78	add_dhcp_options(__name__)
		79
79		80
80	def __init__(self, co, lo, position, dn='', superordinate=None, attributes = [] ):	81	class object(DhcpOptions):
81	global mapping	82	module = module
82	global property_descriptions
83		83
84	self.mapping=mapping	84	def __init__(self, co, lo, position, dn='', superordinate=None, attributes=[]):
85	self.descriptions=property_descriptions	85	self.mapping = mapping
		86	self.descriptions = property_descriptions
86		87
87	if not superordinate:	88	if not superordinate:
88	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'	89	raise univention.admin.uexceptions.insufficientInformation, 'superordinate object not present'
89	if not dn and not position:	90	if not dn and not position:
90	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'	91	raise univention.admin.uexceptions.insufficientInformation, 'neither dn nor position present'
91		92
92	univention.admin.handlers.simpleLdap.__init__(self, co, lo, position, dn, superordinate, attributes = attributes )	93	super(object, self).__init__(co, lo, position, dn, superordinate, attributes=attributes)
93		94	self.setup_options(options)
94	def open(self):
95	univention.admin.handlers.simpleLdap.open(self)
96
97	self.save()
98		95
99	def _ldap_pre_create(self):	96	def _ldap_pre_create(self):
100	self.dn='%s=%s,%s' % (mapping.mapName('name'), mapping.mapValue('name', self.info['name']), self.position.getDn())	97	self.dn = '%s=%s,%s' % (
		98	mapping.mapName('name'),
		99	mapping.mapValue('name', self.info['name']),
		100	self.position.getDn(),
		101	)
101		102
102	def _ldap_addlist(self):	103	def _ldap_addlist(self):
103	return [	104	return [
104	('objectClass', ['top', 'dhcpSharedNetwork'])	105	('objectClass', ['top', 'dhcpSharedNetwork'])
105	]	106	]
106		107
107	def lookup(co, lo, filter_s, base='', superordinate=None, scope='sub', unique=0, required=0, timeout=-1, sizelimit=0):
108		108
109	filter=univention.admin.filter.conjunction('&', [	109	@staticmethod
110	univention.admin.filter.expression('objectClass', 'dhcpSharedNetwork')	110	def lookup_filter(filter_s=None, lo=None):
111	])	111	filter_obj = univention.admin.filter.conjunction('&', [
		112	univention.admin.filter.expression('objectClass', 'dhcpSharedNetwork')
		113	])
		114	filter_obj.append_unmapped_filter_string(filter_s, univention.admin.mapping.mapRewrite, mapping)
		115	return filter_obj
112		116
113	if filter_s:
114	filter_p=univention.admin.filter.parse(filter_s)
115	univention.admin.filter.walk(filter_p, univention.admin.mapping.mapRewrite, arg=mapping)
116	filter.expressions.append(filter_p)
117		117
118	res=[]	118	lookup_filter = object.lookup_filter
119	for dn, attrs in lo.search(unicode(filter), base, scope, [], unique, required, timeout, sizelimit):	119	lookup = object.lookup
120	res.append((object(co, lo, None, dn=dn, superordinate=superordinate, attributes = attrs )))	120
121	return res
122		121
123	def identify(dn, attr):	122	def identify(dn, attr):
124
125	return 'dhcpSharedNetwork' in attr.get('objectClass', [])	123	return 'dhcpSharedNetwork' in attr.get('objectClass', [])
126