class Address(object): address_type = FieldProperty(IAddress['address_type']) line1 = FieldProperty(IAddress['line1']) line2 = FieldProperty(IAddress['line2']) city = FieldProperty(IAddress['city']) country = FieldProperty(IAddress['country']) # Uncomment, if you want to try the relationfield # link = FieldProperty(IAddress['link']) # allow getSource to proceed _Modify_portal_content_Permission = ('Anonymous', ) def __init__(self, address_type=None, line1=None, line2=None, city=None, country=None, link=None): self.address_type = address_type self.line1 = line1 self.line2 = line2 self.city = city self.country = country self.link = link
class HTMLInputWidget(HTMLFormElement): zope.interface.implements(interfaces.IHTMLInputWidget) readonly = FieldProperty(interfaces.IHTMLInputWidget['readonly']) alt = FieldProperty(interfaces.IHTMLInputWidget['alt']) accesskey = FieldProperty(interfaces.IHTMLInputWidget['accesskey']) onselect = FieldProperty(interfaces.IHTMLInputWidget['onselect'])
class ApiGatewayMethod(Resource): type = "ApiGatewayMethod" resource_id = FieldProperty(schemas.IApiGatewayMethod['resource_id']) http_method = FieldProperty(schemas.IApiGatewayMethod['http_method']) request_parameters = FieldProperty(schemas.IApiGatewayMethod['request_parameters']) method_responses = FieldProperty(schemas.IApiGatewayMethod['method_responses']) integration = FieldProperty(schemas.IApiGatewayMethod['integration']) @property def integration_cfn(self): return self.integration.cfn_export_dict troposphere_props = troposphere.apigateway.Method.props cfn_mapping = { #"ApiKeyRequired": (bool, False), #"AuthorizationScopes": ([basestring], False), #"AuthorizerId": (basestring, False), #"RequestModels": (dict, False), #"RequestValidatorId": (basestring, False), "AuthorizationType": 'authorization_type', "HttpMethod": 'http_method', "Integration": 'integration_cfn', #"MethodResponses": 'method_responses', "OperationName": 'title', "RequestParameters": 'request_parameters', # "ResourceId": computed in the template looked up via resource_id # "RestApiId": computed in the template }
class BankAccount(Item): """Holds all relevant informations for direct debit payment method. This is a bank account. """ implements(IBankAccount) portal_type = "BankAccount" account_number = FieldProperty(IBankAccount["account_number"]) bank_identification_code = FieldProperty( IBankAccount["bank_identification_code"]) bank_name = FieldProperty(IBankAccount["bank_name"]) depositor = FieldProperty(IBankAccount["depositor"]) def Title(self): """ """ return self.bank_name + " - " + self.account_number def displayInfo(self): """ returns relevant payment information as dictionary """ return ( self.account_number, self.bank_identification_code, self.bank_name, self.depositor, )
class DatasetQueryAction(Named): filters = FieldProperty(schemas.IDatasetQueryAction['filters']) sql_query = FieldProperty(schemas.IDatasetQueryAction['sql_query']) def __init__(self, name, __parent__): super().__init__(name, __parent__) self.filters = []
class Example(Quotation): zope.interface.implements(IExample) quid = FieldProperty(IExample['quid']) pro_quo = FieldProperty(IExample['pro_quo']) marker = FieldProperty(IExample['marker'])
class CreditCard(Item): """Holds all relevant information of a credit cart. """ implements(ICreditCard) portal_type = "CreditCard" card_type = FieldProperty(ICreditCard["card_type"]) card_owner = FieldProperty(ICreditCard["card_owner"]) card_number = FieldProperty(ICreditCard["card_number"]) card_expiration_date_month = FieldProperty( ICreditCard["card_expiration_date_month"]) card_expiration_date_year = FieldProperty( ICreditCard["card_expiration_date_year"]) def Title(self): """ """ return "%s (%s)" % (self.card_number, self.card_type) def displayInfo(self): """ returns relevant payment information as tuple """ return ( self.card_type, self.card_owner, self.card_number, "%s/%s" % (self.card_expiration_date_month, self.card_expiration_date_year), )
class IoTDataset(Named, StorageRetention): container_action = FieldProperty(schemas.IIoTDataset['container_action']) query_action = FieldProperty(schemas.IIoTDataset['query_action']) content_delivery_rules = FieldProperty( schemas.IIoTDataset['content_delivery_rules']) triggers = FieldProperty(schemas.IIoTDataset['triggers']) version_history = FieldProperty(schemas.IIoTDataset['version_history'])
class HTMLTextAreaWidget(HTMLFormElement): rows = FieldProperty(interfaces.IHTMLTextAreaWidget['rows']) cols = FieldProperty(interfaces.IHTMLTextAreaWidget['cols']) readonly = FieldProperty(interfaces.IHTMLTextAreaWidget['readonly']) accesskey = FieldProperty(interfaces.IHTMLTextAreaWidget['accesskey']) onselect = FieldProperty(interfaces.IHTMLTextAreaWidget['onselect'])
class AdmUtilUserManagement(Supernode, PluggableAuthentication): """Implementation of local UserManagement Utility""" implements(IAdmUtilUserManagement, IAdmUtilUserPreferences) adapts(IPrincipal) serverURL = FieldProperty(IAdmUtilUserManagement['serverURL']) baseDN = FieldProperty(IAdmUtilUserManagement['baseDN']) useLdap = FieldProperty(IAdmUtilUserManagement['useLdap']) #email = FieldProperty(IAdmUtilUserManagement['email']) def __init__(self): PluggableAuthentication.__init__(self) Supernode.__init__(self) self.ikRevision = __version__ def getRequest(self): """ this trick will return the request from the working interaction see http://wiki.zope.org/zope3/FAQProgramming#how-do-i-get-irequest-object-in-event-handler """ i = getInteraction() # raises NoInteraction for i_request in i.participations: if IRequest.providedBy(i_request): return i_request raise RuntimeError('Could not find current request.') # temp. workaround for "user specific timezone" in normal form def get_timezone(self): """ property getter""" try: return AdmUtilUserProperties(self.getRequest().principal).timezone except KeyError, errText: AdmUtilUserProperties(self.getRequest().principal).timezone = u""
class HTMLTextInputWidget(HTMLInputWidget): size = FieldProperty(interfaces.IHTMLTextInputWidget['size']) maxlength = FieldProperty(interfaces.IHTMLTextInputWidget['maxlength']) placeholder = FieldProperty(interfaces.IHTMLTextInputWidget['placeholder']) autocapitalize = FieldProperty( interfaces.IHTMLTextInputWidget['autocapitalize'])
class CloudWatchLogGroup(Named, CloudWatchLogRetention): metric_filters = FieldProperty( schemas.ICloudWatchLogGroup["metric_filters"]) sources = FieldProperty(schemas.ICloudWatchLogGroup["sources"]) log_group_name = FieldProperty( schemas.ICloudWatchLogGroup["log_group_name"]) def __init__(self, name, __parent__): super().__init__(name, __parent__) self.metric_filters = MetricFilters('metric_filters', self) self.sources = CloudWatchLogSources(name, __parent__) def get_log_group_name(self): "Return log_group_name if set, otherwise return name" if self.log_group_name != '': return self.log_group_name return self.name def get_full_log_group_name(self): name = self.get_log_group_name() parent = get_parent_by_interface(self, schemas.ICloudWatchLogSet) if parent != None: return parent.name + '-' + name return name def resolve_ref(self, ref): return self.resolve_ref_obj.resolve_ref(ref)
class MetricTransformation(): default_value = FieldProperty( schemas.IMetricTransformation["default_value"]) metric_name = FieldProperty(schemas.IMetricTransformation["metric_name"]) metric_namespace = FieldProperty( schemas.IMetricTransformation["metric_namespace"]) metric_value = FieldProperty(schemas.IMetricTransformation["metric_value"])
class HTMLTextInputWidget(HTMLInputWidget): """Base HTML text input widget""" size = FieldProperty(IHTMLTextInputWidget['size']) maxlength = FieldProperty(IHTMLTextInputWidget['maxlength']) placeholder = FieldProperty(IHTMLTextInputWidget['placeholder']) autocomplete = FieldProperty(IHTMLTextInputWidget['autocomplete']) autocapitalize = FieldProperty(IHTMLTextInputWidget['autocapitalize'])
class IdChooser(Supernode): """Implementation of host group entry.""" implements(IIdChooser) wasUsed = FieldProperty(IIdChooser['wasUsed']) counter = FieldProperty(IIdChooser['counter']) step = FieldProperty(IIdChooser['step']) format = FieldProperty(IIdChooser['format']) def __init__(self, **data): """ constructor of the object """ Supernode.__init__(self, **data) for (name, value) in data.items(): if name in IIdChooser.names(): setattr(self, name, value) self.ikRevision = __version__ def canBeDeleted(self): """ a object can be deleted with normal delete permission special objects can overload this for special delete rules (e.g. IAdmUtilCatHostGroup) return True or False """ return not self.wasUsed def incrementId(self): """return a unique valid id string. """ self.wasUsed = True self.counter += self.step return self.format % self.counter
class Article: """The article object.""" implements(IArticle) author = FieldProperty(IArticle['author']) title = FieldProperty(IArticle['title']) pages = FieldProperty(IArticle['pages'])
class FormGroupChecker(ObjectDataManagerMixin, Group): """Form group checker A "group checker" is based on a "checker" component provided by MyAMS, which allows to hide or disable a whole fieldset with a checkbox matching a form's field value. """ checker_fieldname = FieldProperty(IFormGroupChecker['checker_fieldname']) checker_mode = FieldProperty(IFormGroupChecker['checker_mode']) def __init__(self, context, request, parent_form): super().__init__(context, request, parent_form) name, field = next(iter(self.fields.items())) self.checker_fieldname = name self.legend = field.field.title self.fields[self.checker_fieldname].widget_factory = SingleCheckBoxFieldWidget @reify def checker_widget(self): """Checker widget getter""" return self.widgets[self.checker_fieldname] @property def checker_state(self): """Checker state getter""" return 'on' if 'selected' in self.checker_widget.value else 'off'
class IoTPolicy(ApplicationResource): policy_json = FieldProperty(schemas.IIoTPolicy['policy_json']) variables = FieldProperty(schemas.IIoTPolicy['variables']) def get_aws_name(self): "Name of the IoT Policy in AWS" ne = get_parent_by_interface(self, schemas.INetworkEnvironment) env = get_parent_by_interface(self, schemas.IEnvironment) app = get_parent_by_interface(self, schemas.IApplication) group = get_parent_by_interface(self, schemas.IResourceGroup) name_list = [ 'ne', ne.name, env.name, 'app', app.name, group.name, self.name, ] aws_name = smart_join('-', name_list) aws_name = aws_name.replace('_', '-').lower() # If the generated policy name is > 128 chars, then prefix a hash of the name if len(aws_name) > 128: name_hash = md5sum(str_data=aws_name)[:8] copy_size = -(128 - 9) if aws_name[copy_size] != '-': name_hash += '-' aws_name = name_hash + aws_name[copy_size:] return aws_name
class BackupSelectionConditionResourceType(Parent): condition_type = FieldProperty( schemas.IBackupSelectionConditionResourceType['condition_type']) condition_key = FieldProperty( schemas.IBackupSelectionConditionResourceType['condition_key']) condition_value = FieldProperty( schemas.IBackupSelectionConditionResourceType['condition_value'])
class Person(object): name = FieldProperty(IPerson['name']) address = FieldProperty(IPerson['address']) def __init__(self, name=None, address=None): self.name = name self.address = address
class CategorizableItemDescription(Persistent, Contained): zope.interface.implements(interfaces.ICategorizableItemDescription) interface = FieldProperty( interfaces.ICategorizableItemDescription['interface']) label = FieldProperty(interfaces.ICategorizableItemDescription['label'])
class SiteControlPanelAdapter(object): adapts(IPloneSiteRoot) implements(ISiteSchema) def __init__(self, context): registry = getUtility(IRegistry) self.settings = registry.forInterface(ISiteSchema, prefix="plone") def get_site_title(self): return self.settings.site_title def set_site_title(self, value): if isinstance(value, str): value = value.decode('utf-8') self.settings.site_title = value def get_webstats_js(self): return self.settings.webstats_js def set_webstats_js(self, value): if isinstance(value, str): value = value.decode('utf-8') self.settings.webstats_js = value site_title = property(get_site_title, set_site_title) webstats_js = property(get_webstats_js, set_webstats_js) site_logo = FieldProperty(ISiteSchema['site_logo']) enable_sitemap = FieldProperty(ISiteSchema['enable_sitemap']) exposeDCMetaTags = FieldProperty(ISiteSchema['exposeDCMetaTags'])
class Assignment(base.Assignment): # We need to explicitly mark our persistant data for @@images view look-up implements(IImagePortlet, IImageScaleTraversable) # Make sure default values work correctly migration proof manner text = FieldProperty(IImagePortlet["text"]) headingText = FieldProperty(IImagePortlet["headingText"]) image = FieldProperty(IImagePortlet["image"]) image2 = FieldProperty(IImagePortlet["image2"]) link = FieldProperty(IImagePortlet["link"]) def __init__(self, **kwargs): self.__dict__.update(**kwargs) def modified(self): """ plone.namedfield uses this information to refresh image URLs when the content changes (cache busting) """ return DateTime(self._p_mtime) @property def title(self): """ Be smart as what show as the management interface title. """ entries = [self.headingText, u"Image portlet"] for e in entries: if e: return e
class VPC(Named, Deployable): "VPC" def __init__(self, name, __parent__): super().__init__(name, __parent__) self.nat_gateway = NATGateways('nat_gateway', self) self.vpn_gateway = VPNGateways('vpn_gateway', self) self.security_groups = SecurityGroupSets('security_groups', self) self.segments = Segments('segments', self) self.peering = VPCPeerings('peering', self) cidr = FieldProperty(schemas.IVPC["cidr"]) enable_dns_hostnames = FieldProperty(schemas.IVPC["enable_dns_hostnames"]) enable_dns_support = FieldProperty(schemas.IVPC["enable_dns_support"]) enable_internet_gateway = FieldProperty( schemas.IVPC["enable_internet_gateway"]) nat_gateway = FieldProperty(schemas.IVPC["nat_gateway"]) vpn_gateway = FieldProperty(schemas.IVPC["vpn_gateway"]) private_hosted_zone = FieldProperty(schemas.IVPC["private_hosted_zone"]) security_groups = FieldProperty(schemas.IVPC["security_groups"]) segments = FieldProperty(schemas.IVPC["segments"]) peering = FieldProperty(schemas.IVPC["peering"]) def resolve_ref(self, ref): if ref.last_part == 'vpc': return self return self.resolve_ref_obj.resolve_ref(ref)
class HTMLTextAreaWidget(HTMLFormElement): """Base HTML textarea widget""" rows = FieldProperty(IHTMLTextAreaWidget['rows']) cols = FieldProperty(IHTMLTextAreaWidget['cols']) readonly = FieldProperty(IHTMLTextAreaWidget['readonly']) accesskey = FieldProperty(IHTMLTextAreaWidget['accesskey']) onselect = FieldProperty(IHTMLTextAreaWidget['onselect'])
class IAMUserPermissionCodeBuildResource(Parent): codebuild = FieldProperty( schemas.IIAMUserPermissionCodeBuildResource['codebuild']) permission = FieldProperty( schemas.IIAMUserPermissionCodeBuildResource['permission']) console_access_enabled = FieldProperty( schemas.IIAMUserPermissionCodeBuildResource['console_access_enabled'])
class DropdownMenu(TemplateBasedViewletManager, WeightOrderedViewletManager): """Dropdown menu""" label = FieldProperty(IDropdownMenu['label']) status = FieldProperty(IDropdownMenu['status']) css_class = FieldProperty(IDropdownMenu['css_class']) icon_class = FieldProperty(IDropdownMenu['icon_class'])
class Config(Resource): delivery_frequency = FieldProperty(schemas.IConfig["delivery_frequency"]) global_resources_region = FieldProperty( schemas.IConfig["global_resources_region"]) locations = FieldProperty(schemas.IConfig["locations"]) s3_bucket_logs_account = FieldProperty( schemas.IConfig["s3_bucket_logs_account"]) def __init__(self, name, __parent__): super().__init__(name, __parent__) self.locations = [] def get_accounts(self): """ Resolve the locations field for all accounts. If locations is empty, then all accounts are returned. """ if self.locations == []: return project['accounts'].values() accounts = [] project = get_parent_by_interface(self, schemas.IProject) for location in self.locations: account = references.get_model_obj_from_ref( location.account, project) accounts.append(account) return accounts
class ApiGatewayMethodMethodResponse(): status_code = FieldProperty( schemas.IApiGatewayMethodMethodResponse['status_code']) response_models = FieldProperty( schemas.IApiGatewayMethodMethodResponse['response_models']) response_parameters = FieldProperty( schemas.IApiGatewayMethodMethodResponse['response_parameters'])
class Service(Component): """ the template instance """ implements(IService) shortName = "service" port = FieldProperty(IService['port']) product = FieldProperty(IService['product']) ipprotocol = FieldProperty(IService['ipprotocol']) # for ..Contained we have to: __name__ = __parent__ = None #ikAttr = FieldProperty(IService['ikAttr']) wf_pd_dict = {} wf_pd_dict[WfPdNagios.id] = WfPdNagios AdmUtilWFMC.wf_pd_dict[WfPdNagios.id] = WfPdNagios def __init__(self, **data): """ constructor of the object """ Component.__init__(self, **data) self.product = u"" self.ipprotocol = None for (name, value) in data.items(): if name in IService.names(): setattr(self, name, value) self.ikRevision = __version__
def __set__(self, instance, value): """ Attribute value is set """ FieldProperty.__set__(self, instance, value) if IEventBroker.providedBy(instance): instance.get_event_bus().publish( DataChangeEvent(instance, attribute=self.name, value=value))
def __init__(self, field, name=None): """ Fied initialization """ FieldProperty.__init__(self, field, name) self.name = field.__name__