Returns the list of available properties and their corresponding URLs.
3236
private void taskProperties(RESTRequest request, RESTResponse response) {
        String taskID = RESTHelper.getRequiredParam(request, APIConstants.PARAM_TASK_ID);

        String taskPropertiesText = getMultipleRoutingHelper().getTaskProperties(taskID);
        OutputHelper.writeTextOutput(response, taskPropertiesText);
    }
577018
def selected_urls(self):
        
        urls = []
        debug('gettings urls')
        for proxy_index in self.tree_view.selectedIndexes():
            finfo = self.tree_view.fileInfo(proxy_index)
            urls.append(finfo.canonicalFilePath())
        debug('selected urls %r' % [str(url) for url in urls])
        return urls
935890
public Map<String,Object> getProperties()
    {
        Map<String,Object> properties = new Hashtable<String,Object>();
        ParamDispatcher params = this;
        for (Enumeration<String> e = params.keys() ; e.hasMoreElements() ;)
        {
            String strKey = e.nextElement();
            String strValue = params.get(strKey).toString();
            properties.put(strKey, strValue);
        }
        return properties;
    }
554376
def _load_properties(self):
        """"""
        method = 'flickr.people.getInfo'
        data = _doget(method, user_id=self.__id)

        self.__loaded = True
        
        person = data.rsp.person

        self.__isadmin = person.isadmin
        self.__ispro = person.ispro
        self.__icon_server = person.iconserver
        if int(person.iconserver) > 0:
            self.__icon_url = 'http://photos%s.flickr.com/buddyicons/%s.jpg' \
                              % (person.iconserver, self.__id)
        else:
            self.__icon_url = 'http://www.flickr.com/images/buddyicon.jpg'
        
        self.__username = person.username.text
        self.__realname = person.realname.text
        self.__location = person.location.text
        self.__photos_firstdate = person.photos.firstdate.text
        self.__photos_firstdatetaken = person.photos.firstdatetaken.text
        self.__photos_count = person.photos.count.text
936152
def _get_indexes(self):
        """"""
        indexes = {}
        for resource in self._get_elastic_resources():
            try:
                index = self._resource_index(resource)

            except KeyError:  # ignore missing
                continue

            if index not in indexes:
                indexes.update({
                    index: {
                        'resource': self.elastic(resource),
                        'index_settings': {
                            'mappings': {}
                        }
                    }
                })

                settings = self._resource_config(resource, 'SETTINGS')
                if settings:
                    indexes[index]['index_settings'].update(settings)

            resource_config = self.app.config['DOMAIN'][resource]
            properties = self._get_mapping_properties(resource_config, parent=self._get_parent_type(resource))
            datasource = self.get_datasource(resource)
            indexes[index]['index_settings']['mappings'][datasource[0]] = properties

        return indexes
1137047
def _load_properties(self):
        """"""
        self.__loaded = True
        
        method = 'flickr.photos.getInfo'
        data = _doget(method, photo_id=self.id)
        
        photo = data.rsp.photo

        self.__secret = photo.secret
        self.__server = photo.server
        self.__isfavorite = photo.isfavorite
        self.__license = photo.license
        self.__rotation = photo.rotation
        


        owner = photo.owner
        self.__owner = User(owner.nsid, username=owner.username,\
                          realname=owner.realname,\
                          location=owner.location)

        self.__title = photo.title.text
        self.__description = photo.description.text
        self.__ispublic = photo.visibility.ispublic
        self.__isfriend = photo.visibility.isfriend
        self.__isfamily = photo.visibility.isfamily

        self.__dateposted = photo.dates.posted
        self.__datetaken = photo.dates.taken
        self.__takengranularity = photo.dates.takengranularity
        
        self.__cancomment = photo.editability.cancomment
        self.__canaddmeta = photo.editability.canaddmeta
        self.__comments = photo.comments.text

        try:
            self.__permcomment = photo.permissions.permcomment
            self.__permaddmeta = photo.permissions.permaddmeta
        except AttributeError:
            self.__permcomment = None
            self.__permaddmeta = None

        #TODO: Implement Notes?
        if hasattr(photo.tags, "tag"):
            if isinstance(photo.tags.tag, list):
                self.__tags = [Tag(tag.id, User(tag.author), tag.raw, tag.text) \
                               for tag in photo.tags.tag]
            else:
                tag = photo.tags.tag
                self.__tags = [Tag(tag.id, User(tag.author), tag.raw, tag.text)]
329319
def get_all_client_properties(self, params=None):
        
        return self._iterate_through_pages(
            get_function=self.get_client_properties_per_page,
            resource=CLIENT_PROPERTIES,
            **{'params': params}
        )
798499
def get_urlpatterns(self):
        
        return [
            path(
                _('topic/<str:slug>-<int:pk>/lock/'),
                self.topic_lock_view.as_view(),
                name='topic_lock',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/unlock/'),
                self.topic_unlock_view.as_view(),
                name='topic_unlock',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/delete/'),
                self.topic_delete_view.as_view(),
                name='topic_delete',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/move/'),
                self.topic_move_view.as_view(),
                name='topic_move',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/change/topic/'),
                self.topic_update_to_normal_topic_view.as_view(),
                name='topic_update_to_post',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/change/sticky/'),
                self.topic_update_to_sticky_topic_view.as_view(),
                name='topic_update_to_sticky',
            ),
            path(
                _('topic/<str:slug>-<int:pk>/change/announce/'),
                self.topic_update_to_announce_view.as_view(),
                name='topic_update_to_announce',
            ),
            path(_('queue/'), self.moderation_queue_list_view.as_view(), name='queue'),
            path(
                _('queue/<int:pk>/'),
                self.moderation_queue_detail_view.as_view(),
                name='queued_post',
            ),
            path(
                _('queue/<int:pk>/approve/'),
                self.post_approve_view.as_view(),
                name='approve_queued_post',
            ),
            path(
                _('queue/<int:pk>/disapprove/'),
                self.post_disapprove_view.as_view(),
                name='disapprove_queued_post',
            ),
        ]
1241331
def _extract_parameters_from_properties(properties):
    """"""
    new_properties = {}
    parameters = []
    for key, value in six.iteritems(properties):
        if key.startswith(_PARAMETER_PREFIX):
            parameters.append((key.replace(_PARAMETER_PREFIX, ""), value))
        else:
            new_properties[key] = value

    return new_properties, sorted(parameters)
148921
@Override
    public final Map<String, String[]> getProperties() {
        final MultivaluedMapPopulator<String, String> populator =
                new MultivaluedMapPopulator<String, String>();
        this.requestPropertiesManager.populateRequestProperties(
                this.servletRequest, portletWindow, populator);
        final Map<String, List<String>> map = populator.getMap();
        return ParameterMap.convertListMap(map);
    }
141232
private List<String> locatePomProperties() {
        List<String> propertiesFiles = new ArrayList<>();
        List<URL> packageUrls = ClasspathUtils.getResources(getResourceBasePath());
        for (URL packageUrl : packageUrls) {
            if (packageUrl.getProtocol().equals("jar")) {
                // We only care about Webjars jar files
                log.debug("Scanning {}", packageUrl);
                try {
                    String jar = packageUrl.toString().substring("jar:".length()).split("!")[0];
                    File file = new File(new URI(jar));
                    try (JarInputStream is = new JarInputStream(new FileInputStream(file))) {
                        JarEntry entry = null;
                        while ((entry = is.getNextJarEntry()) != null) {
                            if (!entry.isDirectory() && entry.getName().endsWith("pom.properties")) {
                                propertiesFiles.add(entry.getName());
                            }
                        }
                    }
                } catch (URISyntaxException | IOException e) {
                    throw new PippoRuntimeException("Failed to get classes for package '{}'", packageUrl);
                }
            }
        }

        return propertiesFiles;
    }
288222
def _property_names(self):
        
        property_names = []

        for name in dir(self):
            try:
                attr = getattr(type(self), name)

                if isinstance(attr, property) or isinstance(attr, cached_property):
                    property_names.append(name)

            except AttributeError:
                pass

        return property_names
139820
public Map<String,Object> getServerProperties()
    {
        Map<String,Object> properties = super.getServerProperties();
        return BaseDatabase.addDBProperties(properties, this, null);
    }
954395
public function getProperties()
    {
        $url      = UrlHelper::buildUrl(Urls::URL_QUERY_CACHE);
        $response = $this->getConnection()->get($url);

        return $response->getJson();
    }
873674
private List<String> existingDangerousProperties() {
        String[] lines = propertiesReader();
        List<String> propertiesFound = new ArrayList<>();
        for (String line : lines) {
            for (String key : DANGEROUS_PROPERTIES.keySet()) {
                if (line.contains(key) && line.contains(DANGEROUS_PROPERTIES.get(key))) {
                    propertiesFound.add(line);
                }
            }
        }
        return propertiesFound;
    }
80359
def get_urlpatterns(self):
        
        return [
            path(
                _('profile/edit/'),
                self.forum_profile_update_view.as_view(),
                name='profile_update',
            ),
            path(
                _('profile/<str:pk>/'),
                self.forum_profile_detail_view.as_view(),
                name='profile',
            ),
            path(
                _('profile/<str:pk>/posts/'),
                self.user_posts_list.as_view(),
                name='user_posts',
            ),
            path(
                _('subscriptions/'),
                self.topic_subscription_list_view.as_view(),
                name='user_subscriptions',
            ),
            path(
                _('topic/<int:pk>/subscribe/'),
                self.topic_subscribe_view.as_view(),
                name='topic_subscribe',
            ),
            path(
                _('topic/<int:pk>/unsubscribe/'),
                self.topic_unsubscribe_view.as_view(),
                name='topic_unsubscribe',
            ),
        ]
149119
public static Properties getProperties(URL url) throws IOException
    {
        Properties properties = new Properties();

        InputStream inputStream = url.openStream();
        try
        {
            properties.load(inputStream);
        }
        finally
        {
            inputStream.close();
        }

        return properties;
    }