text:
package io.demiseq.jetreader.model;

import android.os.Parcel;
import android.os.Parcelable;

/**
 * Created by Thanh on 6/29/2015.
 */
public class Manga implements Parcelable {
    private String name;
    private String url;
    private String description;
    private String image;
    private String latest;
    private Chapter chapter;
    private boolean isFav;

    public Manga(){

    }

    public Manga(String n, String i) {
        name = n;
        image = i;
        isFav = false;
    }

    public Manga(String n, String i, Chapter c) {
        name = n;
        image = i;
        chapter = c;
        isFav = false;
    }

    public Manga(String n, String u, String i, String l) {
        name = n;
        url = u;
        image = i;
        latest = l;
        isFav = false;
    }

    public boolean isFav() {
        return isFav;
    }

    public void setIsFav(boolean isFav) {
        this.isFav = isFav;
    }

    public String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public String getLatest() {
        return latest;
    }

    public void setLatest(String latest) {
        this.latest = latest;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Chapter getChapter() {
        return chapter;
    }

    public void setChapter(Chapter chapter) {
        this.chapter = chapter;
    }

    @Override
    public String toString() {
        return name + ": " +latest;
    }

    protected Manga(Parcel in) {
        name = in.readString();
        url = in.readString();
        description = in.readString();
        image = in.readString();
        latest = in.readString();
        isFav = in.readByte() != 0x00;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeString(url);
        dest.writeString(description);
        dest.writeString(image);
        dest.writeString(latest);
        dest.writeByte((byte) (isFav ? 0x01 : 0x00));
    }

    @SuppressWarnings("unused")
    public static final Parcelable.Creator<Manga> CREATOR = new Parcelable.Creator<Manga>() {
        @Override
        public Manga createFromParcel(Parcel in) {
            return new Manga(in);
        }

        @Override
        public Manga[] newArray(int size) {
            return new Manga[size];
        }
    };
}


text:
using System.Text.RegularExpressions;
using JetBrains.Annotations;
using Newtonsoft.Json;

namespace VimeoDotNet.Models
{
    /// <summary>
    /// Album model
    /// </summary>
    public class Album
    {
        /// <summary>
        /// URI
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "uri")]
        public string Uri { get; set; }

        /// <summary>
        /// User
        /// </summary>

        [PublicAPI]
        [JsonProperty(PropertyName = "user")]
        public User User { get; set; }

        /// <summary>
        /// Name
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "name")]
        public string Name { get; set; }

        /// <summary>
        /// Description
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "description")]
        public string Description { get; set; }

        /// <summary>
        /// Link
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "link")]
        public string Link { get; set; }

        /// <summary>
        /// Duration
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "duration")]
        public int Duration { get; set; }

        /// <summary>
        /// CreatedTime
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "created_time")]
        public string CreatedTime { get; set; }

        /// <summary>
        /// Pictures
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "pictures")]
        public Pictures Pictures { get; set; }

        /// <summary>
        /// Privacy
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "privacy")]
        public Privacy Privacy { get; set; }

        /// <summary>
        /// Stats
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "stats")]
        public AlbumStats Stats { get; set; }

        /// <summary>
        /// Metadata
        /// </summary>
        [PublicAPI]
        [JsonProperty(PropertyName = "metadata")]
        public AlbumMetadata Metadata { get; set; }

        /// <summary>
        /// Return album id if exists
        /// </summary>
        /// <returns>AlbumId or null</returns>
        [PublicAPI]
        public long? GetAlbumId()
        {
            if (string.IsNullOrEmpty(Uri))
            {
                return null;
            }

            var match = RegexAlbumUri.Match(Uri);
            if (match.Success)
            {
                return long.Parse(match.Groups["albumId"].Value);
            }

            return null;
        }

        private static readonly Regex RegexAlbumUri = new Regex(@"/albums/(?<albumId>\d+)/?$");
    }
}

redpajama_set_name: RedPajamaGithub


text:
@interface SelectBandVC ()

@end

@implementation SelectBandVC

- (void)viewDidLoad {
    [super viewDidLoad];
    if (self.dataSources.count == 0) {
        self.dataSources  = @[@"请选择开户行",@"中国农业银行"].mutableCopy;
    }
    [self createTableView];
    CGFloat height = 100;
    height = MIN(MAX(100, self.dataSources.count * 50.f), 300);
    self.view.frame = CGRectMake(40,(SCreenHegiht - height)/2, SCreenWidth - 80, height);
    self.tableView.frame = self.view.bounds;
    self.tableView.layer.cornerRadius = 5;
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    static NSString * cellId = @"cellId";
    UITableViewCell * cell = [tableView dequeueReusableCellWithIdentifier:cellId];
    if (!cell) {
        cell = [[UITableViewCell alloc]initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellId];
        cell.selectionStyle = UITableViewCellSelectionStyleNone;
        cell.textLabel.font = [UIFont systemFontOfSize:15];
    }
    cell.textLabel.text = self.dataSources[indexPath.row];
    if (indexPath.row == 0) {
        cell.textLabel.textColor = JJWThemeColor;
        cell.textLabel.textAlignment =  NSTextAlignmentCenter;
    }else{
        cell.textLabel.textColor = [UIColor blackColor];
        cell.textLabel.textAlignment =  NSTextAlignmentLeft;
    }
    return cell;
}
-(void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath{
    if (indexPath.row == 0) {
        return;
    }

    if (indexPath.row == 1) {
        if (_block) {
            _block();
        }
    }

    if (_selectBlock) {
        _selectBlock(indexPath.row);
    }
    [tableView deselectRowAtIndexPath:indexPath animated:YES];
}

-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{
    return 50.f;
}

@end


text:
#include <linux/binfmts.h>
#include <linux/types.h>

#ifndef __AA_DOMAIN_H
#define __AA_DOMAIN_H

struct aa_domain {
	int size;
	char **table;
};

int apparmor_bprm_set_creds(struct linux_binprm *bprm);
int apparmor_bprm_secureexec(struct linux_binprm *bprm);
void apparmor_bprm_committing_creds(struct linux_binprm *bprm);
void apparmor_bprm_committed_creds(struct linux_binprm *bprm);

void aa_free_domain_entries(struct aa_domain *domain);
int aa_change_hat(const char *hats[], int count, u64 token, bool permtest);
int aa_change_profile(const char *ns_name, const char *name, bool onexec,
		      bool permtest);

#endif /* __AA_DOMAIN_H */


text:
"""
Statistics for astronomy
"""
import numpy as np
from scipy.stats.distributions import rv_continuous

def bivariate_normal(mu=[0, 0], sigma_1=1, sigma_2=1, alpha=0,
                     size=None, return_cov=False):
    """Sample points from a 2D normal distribution

    Parameters
    ----------
    mu : array-like (length 2)
        The mean of the distribution
    sigma_1 : float
        The unrotated x-axis width
    sigma_2 : float
        The unrotated y-axis width
    alpha : float
        The rotation counter-clockwise about the origin
    size : tuple of ints, optional
        Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are
        generated, and packed in an `m`-by-`n`-by-`k` arrangement.  Because
        each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.
        If no shape is specified, a single (`N`-D) sample is returned.
    return_cov : boolean, optional
        If True, return the computed covariance matrix.

    Returns
    -------
    out : ndarray
        The drawn samples, of shape *size*, if that was provided.  If not,
        the shape is ``(N,)``.

        In other words, each entry ``out[i,j,...,:]`` is an N-dimensional
        value drawn from the distribution.

    cov : ndarray
        The 2x2 covariance matrix.  Returned only if return_cov == True.

    Notes
    -----
    This function works by computing a covariance matrix from the inputs,
    and calling ``np.random.multivariate_normal()``.  If the covariance
    matrix is available, this function can be called directly.
    """
    # compute covariance matrix
    sigma_xx = ((sigma_1 * np.cos(alpha)) ** 2
                + (sigma_2 * np.sin(alpha)) ** 2)
    sigma_yy = ((sigma_1 * np.sin(alpha)) ** 2
                + (sigma_2 * np.cos(alpha)) ** 2)
    sigma_xy = (sigma_1 ** 2 - sigma_2 ** 2) * np.sin(alpha) * np.cos(alpha)

    cov = np.array([[sigma_xx, sigma_xy],
                    [sigma_xy, sigma_yy]])

    # draw points from the distribution
    x = np.random.multivariate_normal(mu, cov, size)

    if return_cov:
        return x, cov
    else:
        return x

#----------------------------------------------------------------------
# Define some new distributions based on rv_continuous
class trunc_exp_gen(rv_continuous):
    """A truncated positive exponential continuous random variable.

    The probability distribution is::

       p(x) ~ exp(k * x)   between a and b
            = 0            otherwise

    The arguments are (a, b, k)

    %(before_notes)s

    %(example)s

    """
    def _argcheck(self, a, b, k):
        self._const = k / (np.exp(k * b) - np.exp(k * a))
        return (a != b) and not np.isinf(k)

    def _pdf(self, x, a, b, k):
        pdf = self._const * np.exp(k * x)
        pdf[(x < a) | (x > b)] = 0
        return pdf

    def _rvs(self, a, b, k):
        y = np.random.random(self._size)
        return (1. / k) * np.log(1 + y * k / self._const)

trunc_exp = trunc_exp_gen(name="trunc_exp", shapes='a, b, k')

class linear_gen(rv_continuous):
    """A truncated positive exponential continuous random variable.

    The probability distribution is::

       p(x) ~ c * x + d   between a and b
            = 0             otherwise

    The arguments are (a, b, c).  d is set by the normalization

    %(before_notes)s

    %(example)s

    """
    def _argcheck(self, a, b, c):
        return (a != b) and not np.isinf(c)

    def _pdf(self, x, a, b, c):
        d = 1. / (b - a) - 0.5 * c * (b + a)
        pdf = c * x + d
        pdf[(x < a) | (x > b)] = 0
        return pdf

    def _rvs(self, a, b, c):
        mu = 0.5 * (a + b)
        W = (b - a)

        x0 = 1. / c / W - mu
        r = np.random.random(self._size)
        return -x0 + np.sqrt(2. * r / c + a * a
                             + 2. * a * x0 + x0 * x0)

linear = linear_gen(name="linear", shapes='a, b, c')


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.yanglin.dao.LossaccessmentCasualitesMapper" >
  <resultMap id="BaseResultMap" type="com.yanglin.model.LossaccessmentCasualites" >
    <!--
      WARNING - @mbggenerated
      This element is automatically generated by MyBatis Generator, do not modify.
    -->
    <result column="baoanhao" property="baoanhao" jdbcType="VARCHAR" />
    <result column="xingming" property="xingming" jdbcType="VARCHAR" />
    <result column="xingbie" property="xingbie" jdbcType="VARCHAR" />
    <result column="shangwang_leibie" property="shangwangLeibie" jdbcType="VARCHAR" />
  </resultMap>
  <insert id="insert" parameterType="com.yanglin.model.LossaccessmentCasualites" >
    <!--
      WARNING - @mbggenerated
      This element is automatically generated by MyBatis Generator, do not modify.
    -->
    insert into lossaccessment_casualites (baoanhao, xingming, xingbie,
      shangwang_leibie)
    values (#{baoanhao,jdbcType=VARCHAR}, #{xingming,jdbcType=VARCHAR}, #{xingbie,jdbcType=VARCHAR},
      #{shangwangLeibie,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.yanglin.model.LossaccessmentCasualites" >
    <!--
      WARNING - @mbggenerated
      This element is automatically generated by MyBatis Generator, do not modify.
    -->
    insert into lossaccessment_casualites
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="baoanhao != null" >
        baoanhao,
      </if>
      <if test="xingming != null" >
        xingming,
      </if>
      <if test="xingbie != null" >
        xingbie,
      </if>
      <if test="shangwangLeibie != null" >
        shangwang_leibie,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="baoanhao != null" >
        #{baoanhao,jdbcType=VARCHAR},
      </if>
      <if test="xingming != null" >
        #{xingming,jdbcType=VARCHAR},
      </if>
      <if test="xingbie != null" >
        #{xingbie,jdbcType=VARCHAR},
      </if>
      <if test="shangwangLeibie != null" >
        #{shangwangLeibie,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>

  <select id="getLossaccessmentCasualitesByClaimnumber" resultMap="BaseResultMap">
  	select * from lossaccessment_casualites where baoanhao = #{reportNo}

  </select>
</mapper>


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Revis. gen. pl. (Leipzig) 2: 847 (1891)

#### Original name
Cyphella muscicola Fr., 1822

### Remarks
null


text:
> No longer actively maintained.

Basic Zabbix monitoring for Graylog2

Mainly written for my own use, please feel to fork/use and give feedback.

### Branch pre-2.1 - Graylog 2.1 and below

Written using Zabbix 2.4 and Graylog 1.3. Lightly tested, but does no harm anyway.
Confirmed to work on Zabbix 3.0 and Graylog 2.0.3 as well.

### Master branch - Graylog 2.1 and up

Tested using Zabbix 3.2 and Graylog 2.1.1, 2.2.3.

For specific Elasticsearch monitoring, please head over to Elastizabbix (https://github.com/mkhpalm/elastizabbix)

## Requirements
  * jq (https://github.com/stedolan/jq) 1.4+
  * curl

This doesn't require anything on the agent. It is an external script curl'ing to the Graylog2 API.

Please note, if running by hand, that the `poll_data` item has to be run first.

## How to install
  * Create a Graylog2 user with the "reader" role
  * Enter the credentials in the check_graylog_node_creds.txt file.
  * Copy the 2 files to your zabbix's externalscripts directory.
  * Make sure your files permissions are adequate.
  * Import the XML template in Zabbix.
  * Add template to graylog server and subscribe your graylog server hosts to it.

## Usage

Note: As of 2.1, the default API port is 9000; It used to be 12900. You can change it back to the old behavior with ```rest_listen_uri```, pass port 9000 to the zabbix items (tedious) or simply modify the script at the top to change the port.

```
check_graylog_node -H <HOSTNAME> -a <ATTRIBUTE> [-p <GRAYLOG_API_PORT>] [-h] [-d]

Args:
    -H : Hostname or IP address of graylog server
    -a : Attribute to monitor. See list below.
    -p : Graylog API port (default: 12900)
    -d : Debug message to log file (default: false)
    -h : Displays help

List of attributes:
    - node_id : returns graylog node_id
    - node_transport
    - node_is_master
    - node_cluster
    - node_type
    - node_throughput
    - lb_status
    - total_message_count
    - es_cluster_health
    - journal_size
    - journal_num_segments
    - journal_uncommitted_entries
    - journal_events_read
    - journal_events_append
    - buffer_input_utilization
    - buffer_output_utilization
    - buffer_input_utilization_percent
    - buffer_output_utilization_percent
    - poll_data
    - current_deflector (not yet supported, because not accessible via regular user)
    - system_lifecycle
    - system_isprocessing
    - system_tz
    - system_version
    - system_startedat
    - cluster_stream_count
    - cluster_stream_rule_count
    - cluster_user_count
    - cluster_output_count
    - cluster_dashboard_count
    - cluster_input_count
    - cluster_global_input_count
    - cluster_extractor_count
    - cluster_contentpack_count
    - cluster_alerts_count
```


text:
#include "Score.h"

Score::Score()
{

}

Score::Score(int current)
{
	lives = current;
	font = new sf::Font;
	if (!(*font).loadFromFile("arial.ttf"))
	{
		std::puts("error loading font\n");
	}
}

int Score::initialize()
{
	unsigned int initial = 3;
	lives = initial;
	return 1;
}

int Score::reduceLives()
{
	--lives;
	return lives;
}

int Score::addLife()
{
	++lives;
	return lives;
}

int Score::getLives()
{
	return lives;
}

void Score::draw(sf::Vector2f& resolution, sf::RenderWindow& window)
{
	/*draw remaining lives on the screen*/
	sf::Text text;
	std::stringstream convert;
	convert << "Lives: " << lives;
	text.setFont(*font);
	text.setString(convert.str());
	text.setCharacterSize(36);
	text.setStyle(sf::Text::Bold);
	text.setColor(sf::Color::White);
	text.setPosition(resolution-sf::Vector2f(150, resolution.y+5));
	window.draw(text);
}


text:
description: An overview of the OIDC Conformant authentication flows, why these changes were made and how you can adopt them.
toc: true
topics:
  - api-authentication
  - oidc
contentType: concept
useCase:
  - secure-api
  - call-api
---
# OIDC-Conformant Authentication Overview

**Released Date**: May 10, 2017

As part of our efforts to improve security and standards-based interoperability, we have implemented several new features in our authentication flows and made changes to existing ones. This document presents an overview of these changes, explains why they were made and points you to other detailed tutorials to help you adopt these changes.

We will start by reviewing the [new features](#what-s-new), and then continue with [what changed](#what-is-changing) and how you can [distinguish which authentication flow is used](#how-to-use-the-new-flows) (the latest or the legacy). Towards the end of this doc, you can find a [summarizing table](#legacy-vs-new) and [links for further reading](#keep-reading).

## What should I read?

If you are new to Auth0, go through the [What's New](#what-s-new) section of this doc. There you can find all the cool new features we introduced, like the ability to create APIs, call them from services, or enable external parties or partners to access protected resources at your API in a secure way. Then head off to the [How to use the new flows](#how-to-use-the-new-flows) section and make sure that your new implementation follows our latest, and more secure, authentication pipeline.

If you are already using Auth0 in your app, you should read the complete doc. We have taken great care to make sure that we do not break our existing customers with this new OIDC conformant implementation. However, you should be aware of all changes and new features, and how you can use them (or avoid doing so). It goes without saying that we strongly encourage you to adopt this authentication pipeline, to improve your app's security.

If you are using Auth0 as a [SAML or WS-Federation identity provider](/protocols/saml/saml-idp-generic) for your application (that is, you're not using OIDC/OAuth), then you do not need to make any changes.

## What's New

### APIs Section in the Dashboard

You can now define your resource server APIs as entities separate from applications using our new APIs dashboard area.

![APIs Dashboard](/media/articles/api-auth/api-dashboard.png)

This lets you decouple your resource server APIs from the applications that consume them and also lets you define third-party applications that you might not control or even fully trust (keep reading for more info).

::: note
For more information on APIs, their role in OAuth and how to configure an API in Auth0 Dashboard, refer to [APIs Overview](/apis).
:::

### Third-Party Applications

Up until recently we were treating every application as first-party application. This means that all applications were considered trusted. Now you have the option to define an application as either first-party or third-party.

Third-party applications are applications that are controlled by different people or organizations who most likely should not have administrative access to your Auth0 domain. They enable external parties or partners to access protected resources at your API in a secure way. A practical application of third-party applications is the creation of "developer centers", which allow users to obtain credentials in order to integrate their applications with your API. Similar functionality is provided by well-known APIs such as Facebook, Twitter, Github, and many others.

So far, third-party applications cannot be created from the dashboard. They must be created through the management API. We have also implemented [Dynamic Client Registration](/api-auth/dynamic-client-registration) functionality. All applications registered through that will be third-party applications.

::: note
For more information, refer to [User consent and third-party applications](/api-auth/user-consent).
:::

### Calling APIs from a Service (machine to machine)

We implemented the OAuth 2.0 Client Credentials grant which allows applications to authenticate as themselves (that is, not on behalf of any user), in order to programmatically and securely obtain access to an API.

::: note
For more information on the Client Credentials grant, refer to [How to Implement the Client Credentials Grant](/flows/guides/client-credentials/call-api-client-credentials).
:::

## What is Changing

### Calling APIs with Access Tokens

Historically, protecting resources on your API has been accomplished using ID Tokens issued to your users after they authenticate in your applications. From now on, you should only use Access Tokens when calling APIs. ID Tokens should only be used by the application to verify that the user is authenticated and get basic user information. The main reason behind this change is security. For details, refer to [Tokens](/tokens).

::: note
For more information, refer to [Calling your APIs with Auth0 tokens](/api-auth/tutorials/adoption/api-tokens).
:::

### User Profile Claims and Scope

Historically, you were able to define and request arbitrary application-specific claims. From now on, your application can request any of the [standard OpenID Connect (OIDC) scopes](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims), as [defined by the OIDC Specification](https://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims), or any <dfn data-key="scope">scopes</dfn> supported by your [API](/apis).

In order to add custom claims to ID Tokens or Access Tokens, they must [conform to a namespaced format](/tokens/guides/create-namespaced-custom-claims) to avoid possible collisions with standard OIDC claims.

To customize the tokens, use Hooks for the Client Credentials Flow, and Rules for the rest of the flows:
- __Client Credentials Flow__: [Customize Tokens using Hooks](/flows/guides/client-credentials/call-api-client-credentials#customize-tokens)
- __Trusted App Flow__: [Customize Tokens using Rules](/api-auth/grant/password#customizing-the-returned-tokens)
- __Single-Page Flow__: [Customize Tokens using Rules](/flows/guides/implicit/call-api-auth-code-pkce#customize-tokens)
- __Regular Web App Flow__: [Customize Tokens using Rules](/flows/guides/auth-code/call-api-auth-code#customize-tokens)
- __Native/Mobile Flow__: [Customize Tokens using Rules](/flows/guides/auth-code-pkce/call-api-auth-code-pkce#customize-tokens)

::: note
For more information, refer to [User profile claims and scope](/api-auth/tutorials/adoption/scope-custom-claims).
:::

### Single Sign-on (SSO)

Initiating an <dfn data-key="single-sign-on">Single Sign-on (SSO)</dfn> session must now happen __only__ from an Auth0-hosted page and not from applications. This means that for SSO to work, you must be using <dfn data-key="universal-login">Universal Login</dfn>. Users must be redirected to the login page and then redirected to your application once authentication is complete.

::: note
Support for SSO from applications is planned for a future release.
:::

Not all [OAuth 2.0 grants](/protocols/oauth2#authorization-grant-types) support SSO at the moment:

      OAuth 2.0 Grant
      Supports SSO?

      Authorization Code
      Yes

      Authorization Code (PKCE)
      Yes

      Implicit
      Yes

      Resource Owner Password
      No

::: note
For more information, refer to [OIDC Single Sign-on (SSO)](/api-auth/tutorials/adoption/single-sign-on).
:::

### Authorization Code Grant

Some changes were introduced in the implementation of Authorization Code grant:

- The `device` request parameter has been removed.
- The `audience` request parameter has been introduced. This denotes the target API for which the token should be issued.
- The returned Access Token is a [JWT](/tokens/concepts/jwts), valid for calling the [/userinfo endpoint](/api/authentication#get-user-info) and the API specified by the `audience` parameter.
- A <dfn data-key="refresh-token">Refresh Token</dfn> will be returned only if the `offline_access` scope was granted.

::: note
For more information, refer to [Authorization Code grant](/api-auth/tutorials/adoption/authorization-code).
:::

### Implicit Grant

Some changes were introduced in the implementation of Implicit grant:

- The `device` request parameter has been removed.
- The `audience` request parameter has been introduced. This denotes the target API for which the token should be issued.
- The `response_type` request parameter indicates whether we want to receive both an Access Token and ID Token. If using `response_type=id_token`, we will return only an ID Token.
- Refresh Tokens are not allowed. [Use `prompt=none` instead](/api-auth/tutorials/silent-authentication).
- The <dfn data-key="nonce">`nonce`</dfn> request parameter must be a [cryptographically-secure random string](/api-auth/tutorials/nonce). After validating the ID Token, the application must [validate the nonce to mitigate replay attacks](/api-auth/tutorials/nonce). Requests made without a `nonce` parameter will be rejected.
- The returned Access Token is a [JWT](/tokens/concepts/jwts), valid for calling the [/userinfo endpoint](/api/authentication#get-user-info) and the API specified by the `audience` parameter.
- ID Tokens will be signed asymmetrically using `RS256`.

::: note
For more information, refer to [Implicit grant](/api-auth/tutorials/adoption/implicit).
:::

### Resource Owner Password Grant

Some changes were introduced in the implementation of Resource Owner Password grant:

- The `device` request parameter has been removed.
- The `audience` request parameter has been introduced. This denotes the target API for which the token should be issued.
- The endpoint to execute token exchanges is [/oauth/token](/api/authentication#resource-owner-password).
- [Auth0's own grant type](/api-auth/tutorials/password-grant#realm-support) is used to authenticate users from a specific connection (`realm`). The [standard OIDC password grant](/api-auth/tutorials/password-grant) is also supported, but it does not accept Auth0-specific parameters such as `realm`.
- The returned Access Token is a [JWT](/tokens/concepts/jwts), valid for calling the [/userinfo endpoint](/api/authentication#get-user-info) and the API specified by the `audience` parameter.
- The ID Token will be forcibly signed using `RS256` if requested by a [public application](/applications/concepts/app-types-confidential-public#public-applications).
- A Refresh Token will be returned only if the `offline_access` scope was granted.

::: note
For more information, refer to [Resource Owner Password Credentials exchange](/api-auth/tutorials/adoption/password).
:::

### Delegation

<%= include('../_includes/_deprecate-delegation') %>

[Delegation](/api/authentication#delegation) is used for many operations:
- Exchanging an ID Token issued to one application for a new one issued to a different application
- Using a Refresh Token to obtain a fresh ID Token
- Exchanging an ID Token for a third-party API token, such as Firebase or AWS.

Given that [ID Tokens should no longer be used as API tokens](/api-auth/tutorials/adoption/api-tokens) and that [Refresh Tokens should be used only at the token endpoint](/api-auth/tutorials/adoption/refresh-tokens), this endpoint is now considered deprecated.

### Passwordless

Our new implementation only supports an [OIDC-conformant](/api-auth/tutorials/adoption) <dfn data-key="passwordless">passwordless</dfn> authentication mechanism when using web applications (with Lock.js or auth0.js).

Native applications need to use Universal Login (with an Auth0-hosted login page). Customers can use the <dfn data-key="lock">Lock</dfn> (Passwordless) template in the [Dashboard](${manage_url}/#/login_settings) under **Universal Login -> Login -> Default Templates**, or customize it to fit specific requirements.

### Other Authentication API endpoints

- [/tokeninfo](/api/authentication#get-token-info): With the new implementation, this endpoint is disabled.

- [/userinfo](/api/authentication#get-user-info): Responses will conform to the OIDC specification, similar to the contents of ID Tokens.

- [/oauth/access_token](/api/authentication#social-with-provider-s-access-token): The [/oauth/access_token](/api/authentication#social-with-provider-s-access-token) endpoint, used on native social authentication on mobile devices (for example, use the Facebook SDK and then this endpoint to create the user in Auth0), is now disabled. The alternative is to open the browser to do social authentication, which is what [Google and Facebook are recommending](https://developers.googleblog.com/2016/08/modernizing-oauth-interactions-in-native-apps.html) since last year.

- [/oauth/ro](/api/authentication#resource-owner): This endpoint will soon be deprecated. Use the password grant instead. Note that the password grant should be used only by highly trusted applications, with the current exception of native apps (not with SPAs). This grant's best use is to be called from the server-side of a regular web app or perhaps the backend API of a SPA. For more information on this grant refer to [Call APIs from Highly Trusted Applications](/api-auth/grant/password).

## How to use the new flows

To use the new pipeline, at least one of the following should apply:

- The application is flagged as __OIDC Conformant__, or
- The `audience` parameter is set in the [/authorize](/api/authentication#authorize-application) or [/token](/api/authentication#get-token) endpoints

If none of these applies, then the legacy flows will be used.

To mark your application as OIDC Conformant: go to [Dashboard](${manage_url}) > click [Applications](${manage_url}/#/applications) > select your application > go to _Settings_ > click the _Show advanced settings_ link at the end > click _OAuth_ > toggle the __OIDC Conformant__ flag.

![OIDC Conformant flag](/media/articles/api-auth/oidc-conformant-flag.png)

To use the `audience` parameter instead, configure your app to send it when initiating an authorization request.

## Legacy vs New

      Legacy
      OIDC

      Define APIs in the Dashboard
      Not Supported
      Supported

      Third-party Applications
      Not Supported
      Supported

      Client Credentials Grant
      This grant does not exist in the legacy pipeline, but the Resource Owner Password Credentials exchange can be used to simulate it by creating a "service user". We strongly discourage the latter approach in favor of using Client Credentials, since it allows defining fine-grained permissions for each API application.
      Supported

      Token used to call an API
      ID Token
      Access Token

      Add arbitrary claims in Tokens
      Supported
      Supported. The namespaced format has to be used.

      SSO
      Supported
      Not supported for Resource Owner grant. For the rest, Universal Login must be employed and users redirected to the login page.

      Access Token format
      Opaque string
      JWT for customer APIs, opaque string for /userinfo only

      Authenticate users from a specific connection (realm)
      Supported (using /oauth/ro)
      New password-realm extension grant

      Passwordless
      Supported
      Not supported at the moment, will be in future releases

      /tokeninfo endpoint
      Supported
      Disabled

      /delegation endpoint
      Supported
      Should only be used to obtain third-party API tokens. A new mechanism will be provided  in future releases.

      /oauth/access_token endpoint
      Supported
      Disabled, an alternative will be added in future releases

      /userinfo endpoint
      Supported
      Supported. Responses will conform to the OIDC specification, similar to the contents of ID Tokens.

      Refresh Tokens with Implicit Grant
      Supported
      Deprecated. Silent authentication should be used instead.

      /ssodata endpoint and getSSOData() method from auth0.js

      Supported (up to auth0.js v8)
      Deprecated. Silent authentication should be used instead.

      Implicit Grant requests without nonce parameter set
      Supported
      Will be rejected.

      device parameter (used to obtain Refresh Tokens)
      Supported
      Not supported. /oauth/token
should be used instead with "grant_type": "refresh_token"

      /oauth/ro endpoint
      Supported
      Replaced with Password Grant

## Keep reading

* [API Authorization index](/api-auth)
* [Tokens](/tokens)


text:
jQuery(document).ready(function($){

	/* ------------------- Client Carousel --------------------- */

	$('.clients-carousel').flexslider({
	    animation: "slide",
		easing: "swing",
	    animationLoop: true,
	    itemWidth: 188,
	    itemMargin: 0,
	    minItems: 1,
	    maxItems: 5,
		controlNav: false,
		directionNav: false,
		move: 1
      });

	/* ------------------ Back To Top ------------------- */

	jQuery('#footer-menu-back-to-top a').click(function(){
		jQuery('html, body').animate({scrollTop:0}, 300);
		return false;
	});

	/* ------------------ Progress Bar ------------------- */
	$(function() {
		$(".meter > span").each(function() {
			$(this)
			.data("origWidth", $(this).width())
			.width(0)
			.animate({
				width: $(this).data("origWidth")
			}, 1200);
		});
	});

	/* --------------------- Tabs ------------------------ */

		(function() {

			var $tabsNav    = $('.tabs-nav'),
				$tabsNavLis = $tabsNav.children('li'),
				$tabContent = $('.tab-content');

			$tabsNav.each(function() {
				var $this = $(this);

				$this.next().children('.tab-content').stop(true,true).hide()
													 .first().show();

				$this.children('li').first().addClass('active').stop(true,true).show();
			});

			$tabsNavLis.on('click', function(e) {
				var $this = $(this);

				$this.siblings().removeClass('active').end()
					 .addClass('active');

				$this.parent().next().children('.tab-content').stop(true,true).hide()
															  .siblings( $this.find('a').attr('href') ).fadeIn();

				e.preventDefault();
			});

		})();

});


text:
global.useBluebird = false;
global.useQ = false;
global.useCreed = true;
var creed = require('../..');
require('../lib/fakesP');

module.exports = creed.coroutine(function* upload(stream, idOrPath, tag, done) {
    try {
        var blob = blobManager.create(account);
        var tx = db.begin();
        var blobId = yield blob.put(stream);
        var file = yield self.byUuidOrPath(idOrPath).get();

        var previousId = file ? file.version : null;
        version = {
            userAccountId: userAccount.id,
            date: new Date(),
            blobId: blobId,
            creatorId: userAccount.id,
            previousId: previousId,
        };
        version.id = Version.createHash(version);
        yield Version.insert(version).execWithin(tx);
        if (!file) {
            var splitPath = idOrPath.split('/');
            var fileName = splitPath[splitPath.length - 1];
            file = {
                id: uuid.v1(),
                userAccountId: userAccount.id,
                name: fileName,
                version: version.id
            }
            var query = yield self.createQuery(idOrPath, file);
            yield query.execWithin(tx);
        }
        yield FileVersion.insert({fileId: file.id, versionId: version.id})
            .execWithin(tx);
        yield File.whereUpdate({id: file.id}, {version: version.id})
            .execWithin(tx);
        tx.commit();
        done();
    } catch (err) {
        tx.rollback();
        done(err);
    }
});


text:
/**
 * @file AppBigPuppySymmetricSpiralMetrics.cpp
 * @brief Implementing the Flemons quadruped model.
 * @author Dawn Hustig-Schultz
 * @date Dec 2015
 * @version 1.0.0
 * $Id$
 */

// This application
#include "BigPuppySymmetricSpiralMetrics.h"
// This library
#include "core/terrain/tgBoxGround.h"
#include "core/tgModel.h"
#include "core/tgSimViewGraphics.h"
#include "core/tgSimulation.h"
#include "core/tgWorld.h"
// Bullet Physics
#include "LinearMath/btVector3.h"
// The C++ Standard Library
#include <iostream>

/**
 * The entry point.
 * @param[in] argc the number of command-line arguments
 * @param[in] argv argv[0] is the executable name
 * @return 0
 */

int main(int argc, char** argv)
{
    std::cout << "AppBigPuppySymmetricSpiralMetrics" << std::endl;

    // First create the ground and world. Specify ground rotation in radians
    const double yaw = 0.0;
    const double pitch = 0.0;
    const double roll = 0.0;
    const tgBoxGround::Config groundConfig(btVector3(yaw, pitch, roll));
    // the world will delete this
    tgBoxGround* ground = new tgBoxGround(groundConfig);

    const tgWorld::Config config(981); // gravity, cm/sec^2 981
    tgWorld world(config, ground);

    // Second create the view
    const double timestep_physics = 0.001; // seconds
    const double timestep_graphics = 1.f/60.f; // seconds
    tgSimViewGraphics view(world, timestep_physics, timestep_graphics);

    // Third create the simulation
    tgSimulation simulation(view);

    //Parameters for the structure:
    const int segments = 7;
    const int hips = 4;
    const int legs = 4;

    BigPuppySymmetricSpiralMetrics* const myModel = new BigPuppySymmetricSpiralMetrics(segments, hips, legs);

    // Add the model to the world
    simulation.addModel(myModel);

    simulation.run();

    //Teardown is handled by delete, so that should be automatic
    return 0;
}


text:
C
C
*+ plot_getpos2

       subroutine plot_getpos2(minirt,prompt,default,uv_pos,status)
C      ------------------------------------------------------------
C
C Read a pixel position - optionally using the cursor
C
C Given:
C   mini-redtape
       integer        minirt(*)
C   prompt
       character*(*)  prompt
C   default string
       character*(*)  default
C
C Returned:
C   UV-position
       real*4         uv_pos(2)
C
C Updated:
C   error status
       integer        status
C
C The user is prompted for a UV position. If the answer supplied is
C CURSOR then the UV position is read from the creen by positioning the
C graphics CURSOR.
C
C [PA, January 1993]
*-
       include '../include/plt_error_defn.inc'
       include '/mrao/include/chrlib_functions.inc'

       character*80    string
       real*4          xy(2)

C read the command line
       if (status.ne.0) return
       string = ' '
       write(string,'(F8.1,F8.1)') uv_pos
       call io_getstr(prompt,default,string,status)
       if (status.ne.0) then
         call cmd_err(status,'UV-POSITION',' ')
         return
       end if

C test for 'cursor' input mode
       call chr_chucas(string)
       if (chr_cmatch(string(1:chr_lenb(string)),'CURSOR')) then
C .. use cursor input
         call plot_cursor_get( xy, status )

       else
C .. normal input
         call io_setcli(string(1:chr_lenb(string)))
         call io_getr(' ',' ',xy(1),status)
         call io_getr(' ',' ',xy(2),status)
         if (status.ne.0) then
           call cmd_err(status,'UV-POSITION','Error in input position')
           status = ill_pos
           return
         end if
       end if
       if (xy(1).lt.float(minirt(1)).or.xy(1).gt.float(minirt(2)).or.
     *     xy(2).lt.float(minirt(4)).or.xy(2).gt.float(minirt(3))) then
         status = ill_pos
         call cmd_wrerr('UV-POSITION','Position outside map')
         return
       end if
       uv_pos(1) = xy(1)
       uv_pos(2) = xy(2)

       end


text:
<?php
namespace Zodream\Infrastructure\Pipeline;
/**
 * Created by PhpStorm.
 * User: zx648
 * Date: 2016/7/18
 * Time: 16:54
 */
interface ProcessorInterface {

    /**
     * Let payload processed the stages.
     * @param array $stages
     * @param mixed $payload
     * @return mixed
     */
    public function process(array $stages, $payload);
}


text:
using System;
using System.Collections.Generic;
using System.Text;
using Judger.Models;
using Judger.Utils;

namespace Judger.Managers
{
    /// <summary>
    /// 配置信息管理器
    /// </summary>
    public static class ConfigManager
    {
        /// <summary>
        /// 配置信息实例
        /// </summary>
        public static Configuration Config { get; }
        static ConfigManager()
        {
            FileHelper.TryReadAllText("Config.json", out string configJson);
            if(string.IsNullOrEmpty(configJson))//创建新配置文件
            {
                Config = new Configuration();
                Config.Password = RandomString.Next(16);
                Config.AdditionalConfig.Add("SampleKey", "SampleValue");
                SaveConfig();
                return;
            }

            Config = SampleJsonSerializaer.DeSerialize<Configuration>(configJson);
            SaveConfig();
        }

        /// <summary>
        /// 保存配置信息
        /// </summary>
        public static void SaveConfig()
        {
            FileHelper.TryWriteAllText("Config.json", SampleJsonSerializaer.Serialize<Configuration>(Config));
        }

        /// <summary>
        /// 获取语言配置信息
        /// </summary>
        /// <param name="languageName">语言名称</param>
        /// <returns>语言对应的配置信息</returns>
        public static LanguageConfiguration GetLanguageConfig(string languageName)
        {
            LanguageConfiguration[] configs = Config.Languages;
            foreach(var item in configs)
            {
                if(item.Language == languageName)
                {
                    return item;
                }
            }

            return null;
        }
    }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<TITLE>
org.apache.hadoop.fs.http.client (Apache Hadoop HttpFS 2.3.0 API)
</TITLE>

<META NAME="date" CONTENT="2015-03-06">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../../stylesheet.css" TITLE="Style">

      Overview
    Package
      Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

  All Classes

Package org.apache.hadoop.fs.http.client

Class Summary

HttpFSFileSystem
HttpFSServer implementation of the FileSystemAccess FileSystem.

HttpFSKerberosAuthenticator
A KerberosAuthenticator subclass that fallback to
 HttpFSPseudoAuthenticator.

HttpFSPseudoAuthenticator
A PseudoAuthenticator subclass that uses FileSystemAccess's
 UserGroupInformation to obtain the client user name (the UGI's login user).

HttpFSUtils
Utility methods used by HttpFS classes.

HttpsFSFileSystem
HttpFSServer implementation of the FileSystemAccess FileSystem for SSL.

Enum Summary

HttpFSFileSystem.FILE_TYPE

HttpFSFileSystem.Operation

HttpFSKerberosAuthenticator.DelegationTokenOperation
DelegationToken operations.

      Overview
    Package
      Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

  All Classes

Copyright © 2015 Apache Software Foundation. All Rights Reserved.


text:
package com.hazelcast.cp.internal.datastructures.lock;

import com.hazelcast.config.Config;
import com.hazelcast.config.cp.FencedLockConfig;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.test.HazelcastParallelClassRunner;
import com.hazelcast.test.annotation.ParallelJVMTest;
import com.hazelcast.test.annotation.QuickTest;
import com.hazelcast.internal.util.RandomPicker;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;

@RunWith(HazelcastParallelClassRunner.class)
@Category({QuickTest.class, ParallelJVMTest.class})
public class NonReentrantFencedLockTest extends AbstractNonReentrantFencedLockTest {

    @Override
    protected HazelcastInstance[] createInstances() {
        return newInstances(3);
    }

    @Override
    protected HazelcastInstance getProxyInstance() {
        return instances[RandomPicker.getInt(instances.length)];
    }

    @Override
    protected String getProxyName() {
        return objectName + "@group";
    }

    @Override
    protected Config createConfig(int cpNodeCount, int groupSize) {
        Config config = super.createConfig(cpNodeCount, groupSize);

        FencedLockConfig lockConfig = new FencedLockConfig(objectName, 1);
        config.getCPSubsystemConfig().addLockConfig(lockConfig);
        return config;
    }

}


text:
#ifndef MODULES_AUDIO_PROCESSING_TEST_FAKE_RECORDING_DEVICE_H_
#define MODULES_AUDIO_PROCESSING_TEST_FAKE_RECORDING_DEVICE_H_

#include <algorithm>
#include <memory>
#include <vector>

#include "api/array_view.h"
#include "common_audio/channel_buffer.h"
#include "rtc_base/checks.h"

namespace webrtc {
namespace test {

class FakeRecordingDeviceWorker;

// Class for simulating a microphone with analog gain.
//
// The intended modes of operation are the following:
//
// FakeRecordingDevice fake_mic(255, 1);
//
// fake_mic.SetMicLevel(170);
// fake_mic.SimulateAnalogGain(buffer);
//
// When the mic level to undo is known:
//
// fake_mic.SetMicLevel(170);
// fake_mic.SetUndoMicLevel(30);
// fake_mic.SimulateAnalogGain(buffer);
//
// The second option virtually restores the unmodified microphone level. Calling
// SimulateAnalogGain() will first "undo" the gain applied by the real
// microphone (e.g., 30).
class FakeRecordingDevice final {
 public:
  FakeRecordingDevice(int initial_mic_level, int device_kind);
  ~FakeRecordingDevice();

  int MicLevel() const;
  void SetMicLevel(const int level);
  void SetUndoMicLevel(const int level);

  // Simulates the analog gain.
  // If |real_device_level| is a valid level, the unmodified mic signal is
  // virtually restored. To skip the latter step set |real_device_level| to
  // an empty value.
  void SimulateAnalogGain(rtc::ArrayView<int16_t> buffer);

  // Simulates the analog gain.
  // If |real_device_level| is a valid level, the unmodified mic signal is
  // virtually restored. To skip the latter step set |real_device_level| to
  // an empty value.
  void SimulateAnalogGain(ChannelBuffer<float>* buffer);

 private:
  // Fake recording device worker.
  std::unique_ptr<FakeRecordingDeviceWorker> worker_;
};

}  // namespace test
}  // namespace webrtc

#endif  // MODULES_AUDIO_PROCESSING_TEST_FAKE_RECORDING_DEVICE_H_


text:
jest.unmock('../Tools')

import React from 'react'
import {shallow} from 'enzyme'

import Tools from '../Tools'

describe('Box.Tools', () => {
  it('should have basic className by default', () => {
    const wrapper = shallow(<Tools />)

    expect(
      wrapper.hasClass('box-tools')
    ).toBeTruthy()
  })

  it('should pass down children', () => {
    const wrapper = shallow(
      <Tools>

Children

      </Tools>
    )

    expect(
      wrapper.contains(
Children
)
    ).toBeTruthy()
  })
})


text:
package com.github.holmistr.esannotations.indexing.annotations;

import java.lang.annotation.*;

/**
 * Annotation to mark simple primitive attributes.
 *
 * @author Jiří Holuša
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Field {

    /**
     * Change the name of the field in the index. If not provided, name with be
     * selected as attribute name.
     *
     * @return
     */
    String name() default "";

}


text:
var log4js = require('log4js');

var Logger = function() {
	log4js.loadAppender('file');

	log4js.addAppender(log4js.appenders.file('logs/experiment_data_' + (new Date()).getTime() + '.csv'), 'experiment_data');
	this.logger = log4js.getLogger('experiment_data');

	var log_line = [
		'time',
		'timestamp',
		'error_rate'
	];
	for (var i = 0; i < 10; i++) {
		log_line.push('learned_locally_' + i);
	}
	for (var i = 0; i < 10; i++) {
		log_line.push('learned_distributedly_' + i);
	}
	this.logger.trace(',' + log_line.join(','));
};

Logger.prototype.log = function(error_rate, learned_locally, learned_distributedly) {
	var log_line = [];
	log_line.push((new Date()).toString());
	log_line.push((new Date()).getTime());
	log_line.push(error_rate);
	log_line = log_line.concat(learned_locally);
	log_line = log_line.concat(learned_distributedly);
	this.logger.trace(',' + log_line.join(','));
};

module.exports = Logger;


text:
package edu.kaist.mrlab.temlator.test;

import java.io.BufferedReader;
import java.io.FileReader;

import edu.kaist.mrlab.templator.pipeline.PipeAll;

public class Tester {

	public static BufferedReader fbr;

	public static void main(String[] ar) throws Exception {

		PipeAll pa = new PipeAll();

		fbr = new BufferedReader(new FileReader("data/input.txt"));
		String question;
		while ((question = fbr.readLine()) != null) {
			System.out.println(question);
			String result = pa.run(question);
			System.out.println(result);
			System.out.println();
		}

	}
}


text:
<?php

namespace directapi\services\adgroups\models;

use directapi\components\Model;
use Symfony\Component\Validator\Constraints as Assert;

class SmartAdGroupGet extends Model
{
    /**
     * @var int
     * @Assert\NotBlank()
     */
    public $FeedId;

    /**
     * @var string
     */
    public $AdTitleSource;

    /**
     * @var string
     */
    public $AdBodySource;
}


text:
/**
 * @ngdoc function
 * @name ngmReportHubApp.controller:ClusterProjectSummaryCtrl
 * @description
 * # ClusterProjectSummaryCtrl
 * Controller of the ngmReportHub
 */
angular.module('ngmReportHub')
	.controller('ClusterSyriaDashboard', ['$scope', '$route', '$http', '$location', 'ngmAuth', 'ngmData', 'ngmUser', function ($scope, $route, $http, $location, ngmAuth, ngmData, ngmUser) {
		this.awesomeThings = [
			'HTML5 Boilerplate',
			'AngularJS',
			'Karma'
		];

		// init empty model
		$scope.model = $scope.$parent.ngm.dashboard.model;

		// report object
		$scope.report = {

			// ngm
			ngm: $scope.$parent.ngm,

			// current user
			user: ngmUser.get(),

			// set summary
			init: function(){

				// report dashboard model
				$scope.model = {
					name: 'cluster_syria_dashboard',
					header: {
						// div: {
						// 	'class': 'col s12 m12 l12'
						// }
						div: {
							'class': 'col s12 m12 l12 report-header',
							style: 'border-bottom: 3px ' + $scope.report.ngm.style.defaultPrimaryColor + ' solid;'
						},
						title: {
							'class': 'col s12 m12 l12 report-title truncate',
							style: 'color: ' + $scope.report.ngm.style.defaultPrimaryColor,
							title: 'SYR | FSAC'
						},
						subtitle: {
							'class': 'col s12 m12 l12 report-subtitle truncate hide-on-small-only',
							'title': 'Overview for Syria'
						}
					},
					menu: [{
						'id': 'back-home',
						'icon': 'keyboard_return',
						'title': 'Back Home',
						'class': 'teal lighten-1 white-text',
						'href': '/desk/#/cluster/organization'
					}],
					rows: [{
						columns: [{
							styleClass: 's12 m12 l12',
							widgets: [{
								type: 'html',
								card: 'white grey-text text-darken-2',
								style: 'padding: 0px;',
								config: {
									project: $scope.report.project,
									user: $scope.report.user,
									templateUrl: '/scripts/modules/cluster/views/cluster.syria.dashboard.html',
								}
							}]
						}]
					},{
						columns: [{
							styleClass: 's12 m12 l12',
							widgets: [{
								type: 'html',
								card: 'card-panel',
								style: 'padding:0px; height: 90px; padding-top:10px;',
								config: {
									// html: $scope.report.ngm.footer
									templateUrl: '/scripts/widgets/ngm-html/template/footer.html',
									lightPrimaryColor: $scope.ngm.style.lightPrimaryColor,
									defaultPrimaryColor: $scope.ngm.style.defaultPrimaryColor,
								}
							}]
						}]
					}]
				};

				// assign to ngm app scope
				$scope.report.ngm.dashboard.model = $scope.model;
				$('.fixed-action-btn').floatingActionButton({ direction: 'left' });

			}

		}

		$scope.report.init();

		// timeout
		setTimeout(function(){
			$('#back-home').on('click', function(){
				console.log('hello')
				$location.path( '/cluster/organization' );
			})
		}, 2000);

	}]);


text:
<!DOCTYPE html>

		<meta charset="utf-8" />
		<base href="../../../" />

		<link type="text/css" rel="stylesheet" href="page.css" />

		[page:Object3D] → [page:Line] → [page:LineSegments] →

[name]

			Helper object to visualize a [page:Box3].

Code Example

		const box = new THREE.Box3();
		box.setFromCenterAndSize( new THREE.Vector3( 1, 1, 1 ), new THREE.Vector3( 2, 1, 3 ) );

		const helper = new THREE.Box3Helper( box, 0xffff00 );
		scene.add( helper );

Constructor

[name]( [param:Box3 box], [param:Color color] )

		[page:Box3 box]  -- the Box3 to show.

		[page:Color color] --  (optional) the box's color. Default is 0xffff00.

		Creates a new wireframe box that represents the passed Box3.

Properties

See the base [page:LineSegments] class for common properties.

[property:Box3 box]

The Box3 being visualized.

Methods

See the base [page:LineSegments] class for common methods.

[method:undefined updateMatrixWorld]( [param:Boolean force] )

			This overrides the method in the base [page:Object3D] class so that it
			also updates the wireframe box to the extent of the [page:Box3Helper.box .box]
			property.

Source

			[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]


text:
import { __decorate, __metadata } from "tslib";
import * as au from "../aurelia";
var MdDropdown = /** @class */ (function () {
    function MdDropdown(element) {
        this.element = element;
        this.activates = "";
        this.ref = null;
        this.attributeManager = new au.AttributeManager(this.element);
    }
    MdDropdown_1 = MdDropdown;
    MdDropdown.prototype.attached = function () {
        var _this = this;
        this.handleActivateElement();
        var dropdownContent = document.getElementById(this.activates);
        this.contentAttributeManager = new au.AttributeManager(dropdownContent);
        this.attributeManager.addClasses("dropdown-trigger");
        this.contentAttributeManager.addClasses("dropdown-content");
        var container = typeof this.container === "string" ? document.querySelector(this.container) : this.container;
        var options = {
            alignment: this.alignment,
            autoTrigger: this.autoTrigger,
            constrainWidth: this.constrainWidth,
            container: container,
            coverTrigger: this.coverTrigger,
            closeOnClick: this.closeOnClick,
            hover: this.hover,
            inDuration: this.inDuration,
            outDuration: this.outDuration,
            onOpenStart: function () { return au.fireMaterializeEvent(_this.element, "open-start"); },
            onOpenEnd: function () { return au.fireMaterializeEvent(_this.element, "open-end"); },
            onCloseStart: function () { return au.fireMaterializeEvent(_this.element, "close-start"); },
            onCloseEnd: function () { return au.fireMaterializeEvent(_this.element, "close-end"); }
        };
        au.cleanOptions(options);
        this.dropdownContentParent = dropdownContent.parentElement;
        this.instance = new M.Dropdown(this.element, options);
    };
    MdDropdown.prototype.detached = function () {
        if (this.instance) {
            this.instance.destroy();
            this.dropdownContentParent.appendChild(this.instance.dropdownEl);
        }
        this.attributeManager.removeAttributes("data-target");
        this.attributeManager.removeClasses("dropdown-trigger");
        this.contentAttributeManager.removeClasses("dropdown-content");
    };
    MdDropdown.prototype.open = function () {
        if (this.instance) {
            this.instance.open();
        }
    };
    MdDropdown.prototype.close = function () {
        if (this.instance) {
            this.instance.close();
        }
    };
    MdDropdown.prototype.recalculateDimensions = function () {
        if (this.instance) {
            this.instance.recalculateDimensions();
        }
    };
    MdDropdown.prototype.handleActivateElement = function () {
        if (this.ref) {
            var id = this.ref.getAttribute("id");
            if (!id) {
                id = "md-dropdown-" + MdDropdown_1.elementId++;
                this.ref.setAttribute("id", id);
                this.activates = id;
            }
            this.id = id;
        }
        this.attributeManager.addAttributes({ "data-target": this.activates });
    };
    var MdDropdown_1;
    MdDropdown.elementId = 0;
    __decorate([
        au.bindable({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Object)
    ], MdDropdown.prototype, "activates", void 0);
    __decorate([
        au.bindable({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Element)
    ], MdDropdown.prototype, "ref", void 0);
    __decorate([
        au.ato.bindable.stringMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", String)
    ], MdDropdown.prototype, "alignment", void 0);
    __decorate([
        au.ato.bindable.booleanMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Boolean)
    ], MdDropdown.prototype, "autoTrigger", void 0);
    __decorate([
        au.ato.bindable.booleanMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Boolean)
    ], MdDropdown.prototype, "constrainWidth", void 0);
    __decorate([
        au.bindable({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Object)
    ], MdDropdown.prototype, "container", void 0);
    __decorate([
        au.ato.bindable.booleanMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Boolean)
    ], MdDropdown.prototype, "coverTrigger", void 0);
    __decorate([
        au.ato.bindable.booleanMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Boolean)
    ], MdDropdown.prototype, "closeOnClick", void 0);
    __decorate([
        au.ato.bindable.booleanMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Boolean)
    ], MdDropdown.prototype, "hover", void 0);
    __decorate([
        au.ato.bindable.stringMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", String)
    ], MdDropdown.prototype, "mdTitle", void 0);
    __decorate([
        au.ato.bindable.numberMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Number)
    ], MdDropdown.prototype, "inDuration", void 0);
    __decorate([
        au.ato.bindable.numberMd({ defaultBindingMode: au.bindingMode.oneTime }),
        __metadata("design:type", Number)
    ], MdDropdown.prototype, "outDuration", void 0);
    MdDropdown = MdDropdown_1 = __decorate([
        au.customAttribute("md-dropdown"),
        au.autoinject,
        __metadata("design:paramtypes", [Element])
    ], MdDropdown);
    return MdDropdown;
}());
export { MdDropdown };
//# sourceMappingURL=dropdown.js.map


text:
title: Supercomputing, algorithms and collective intelligence
event: V Congreso de Inteligencia Colectiva
event_url:

location: Malaga, Spain
address:
  street:
  city: Malaga
  region:
  postcode:
  country: Spain

summary:
abstract: ""

# Talk start and end times.
#   End time can optionally be hidden by prefixing the line with `#`.
date: "2016-12-09T11:30:00Z"
date_end: "2016-12-09T12:30:00Z"
all_day: false

# Schedule page publish date (NOT talk date).
publishDate: "2016-12-09T12:30:00Z"

authors: [admin]
tags: [compss]

# Is this a featured talk? (true/false)
featured: false

image:
  caption: 'Supercomputing, algorithms and collective intelligence'
  focal_point: Smart

links:
- icon: twitter
  icon_pack: fab
  name: Follow
  url: https://twitter.com/cristianrcv

url_code: ""
url_pdf: ""
url_slides: ""
url_video: "https://www.youtube.com/watch?v=IPcfbFLRn-A&list=PLeY7VuKJA5aUS1jZoiKZTl9fqaDb2aJf6&index=3"

# Markdown Slides (optional).
#   Associate this talk with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides: ""

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects:
- compss

# Enable math on this page?
math: true
---

Délivré par

5ème Congrès d'Intelligence Collective (V Congreso de Inteligencia Colectiva)

Titre

Supercomputing, algoritmes et intelligence collective

Titre Original

Supercomputación, algoritmos e inteligencia colectiva

Information

Discussion avec Jaime Martel et Pedro García sur le déploiement dans Amazon EC2 du Moteur d'Intelligence Collective.

Session complète (en Espagnol)