text:
<!DOCTYPE html>

    <meta charset='UTF-8'>
    <title>Instalação do Cacic 3.0</title>
    <link rel='shortcut icon' href='img/logo-bits.png'>
    <link rel='stylesheet' href='css/style.css'>
    <link rel='stylesheet' href='dist/css/bootstrap.css'>
    <link rel='stylesheet' href='dist/css/bootstrap-theme.css'>

        Por favor, leia os termos da licença a seguir.
        Você deve concordar com os termos para utilizar o CACIC!

LICENÇA PÚBLICA GERAL GNU

Versão 2, junho de 1991

Introdução

As licenças de muitos softwares são desenvolvidas para restringir sua
                liberdade de compartilhá-lo e mudá-lo. Contrária a isso, a Licença
                Pública Geral GNU pretende garantir sua liberdade de compartilhar e
                alterar software livres -- garantindo que o software será livre e
                gratuito para os seus usuários. Esta Licença Pública Geral aplica-se à
                maioria dos software da Free Software Foundation e a qualquer outro
                programa cujo autor decida aplicá-la. (Alguns outros software da FSF
                são cobertos pela Licença Pública Geral de Bibliotecas, no entanto.)
                Você pode aplicá-la também aos seus programas.

Quando nos referimos a software livre, estamos nos referindo a
                liberdade e não a preço. Nossa Licença Pública Geral foi desenvolvida
                para garantir que você tenha a liberdade de distribuir cópias de
                software livre (e cobrar por isso, se quiser); que você receba o
                código-fonte ou tenha acesso a ele, se quiser; que você possa mudar o
                software ou utilizar partes dele em novos programas livres e
                gratuitos; e que você saiba que pode fazer tudo isso.

Para proteger seus direitos, precisamos fazer restrições que impeçam
                a qualquer um negar estes direitos ou solicitar que você deles
                abdique. Estas restrições traduzem-se em certas responsabilidades para
                você, se você for distribuir cópias do software ou modificá-lo.

Por exemplo, se você distribuir cópias de um programa, gratuitamente
                ou por alguma quantia, você tem que fornecer aos recebedores todos os
                direitos que você possui. Você tem que garantir que eles também
                recebam ou possam obter o código-fonte. E você tem que mostrar-lhes
                estes termos para que eles possam conhecer seus direitos.

Nós protegemos seus direitos em dois passos: (1) com copyright do
                software e (2) com a oferta desta licença, que lhe dá permissão legal
                para copiar, distribuir e/ou modificar o software.

Além disso, tanto para a proteção do autor quanto a nossa,
                gostaríamos de certificar-nos que todos entendam que não há qualquer
                garantia nestes software livres. Se o software é modificado por alguém
                mais e passado adiante, queremos que seus recebedores saibam que o que
                eles obtiveram não é original, de forma que qualquer problema
                introduzido por terceiros não interfira na reputação do autor
                original.

Finalmente, qualquer programa é ameaçado constantemente por patentes
                de software. Queremos evitar o perigo de que distribuidores de
                software livre obtenham patentes individuais, o que tem o efeito de
                tornar o programa proprietário. Para prevenir isso, deixamos claro que
                qualquer patente tem que ser licenciada para uso livre e gratuito por
                qualquer pessoa, ou então que nem necessite ser licenciada.

Os termos e condições precisas para cópia, distribuição e
                modificação se encontram abaixo:

LICENÇA PÚBLICA GERAL GNU

TERMOS E CONDIÇÕES PARA CÓPIA, DISTRIBUIÇÃO E MODIFICAÇÃO

0. Esta licença se aplica a qualquer programa ou outro trabalho que
                contenha um aviso colocado pelo detentor dos direitos autorais
                informando que aquele pode ser distribuído sob as condições desta
                Licença Pública Geral. O 'Programa' abaixo refere-se a qualquer
                programa ou trabalho, e 'trabalho baseado no Programa' significa tanto
                o Programa em si como quaisquer trabalhos derivados, de acordo com a
                lei de direitos autorais: isto quer dizer um trabalho que contenha o
                Programa ou parte dele, tanto originalmente ou com modificações, e/ou
                tradução para outros idiomas. (Doravante o processo de tradução está
                incluído sem limites no termo 'modificação'.) Cada licenciado é
                mencionado como 'você'.

Atividades outras que a cópia, a distribuição e modificação não estão
                cobertas por esta Licença; elas estão fora de seu escopo.  O ato de
                executar o Programa não é restringido e o resultado do Programa é
                coberto apenas se seu conteúdo contenha trabalhos baseados no Programa
                (independentemente de terem sido gerados pela execução do
                Programa). Se isso é verdadeiro depende do que o programa faz.

1. Você pode copiar e distribuir cópias fiéis do código-fonte do
                Programa da mesma forma que você o recebeu, usando qualquer meio,
                deste que você conspícua e apropriadamente publique em cada cópia um
                aviso de direitos autorais e uma declaração de inexistência de
                garantias; mantenha intactas todos os avisos que se referem a esta
                Licença e à ausência total de garantias; e forneça a outros
                recebedores do Programa uma cópia desta Licença, junto com o Programa.

Você pode cobrar pelo ato físico de transferir uma cópia e pode,
                opcionalmente, oferecer garantia em troca de pagamento.

2. Você pode modificar sua cópia ou cópias do Programa, ou qualquer
                parte dele, assim gerando um trabalho baseado no Programa, e copiar e
                distribuir essas modificações ou trabalhos sob os termos da seção 1
                acima, desde que você também se enquadre em todas estas condições:

a) Você tem que fazer com que os arquivos modificados levem avisos
                    proeminentes afirmando que você alterou os arquivos, incluindo a data
                    de qualquer alteração.

b) Você tem que fazer com que quaisquer trabalhos que você
                    distribua ou publique, e que integralmente ou em partes contenham
                    ou sejam derivados do Programa ou de suas partes, sejam
                    licenciados, integralmente e sem custo algum para quaisquer
                    terceiros, sob os termos desta Licença.

c) Se qualquer programa modificado normalmente lê comandos
                    interativamente quando executados, você tem que fazer com que,
                    quando iniciado tal uso interativo da forma mais simples, seja
                    impresso ou mostrado um anúncio de que não há qualquer garantia
                    (ou então que você fornece a garantia) e que os usuários podem
                    redistribuir o programa sob estas condições, ainda informando os
                    usuários como consultar uma cópia desta Licença. (Exceção: se o
                    Programa em si é interativo mas normalmente não imprime estes
                    tipos de anúncios, seu trabalho baseado no Programa não precisa
                    imprimir um anúncio.)

Estas exigências aplicam-se ao trabalho modificado como um todo. Se
                seções identificáveis de tal trabalho não são derivadas do Programa, e
                podem ser razoavelmente consideradas trabalhos independentes e
                separados por si só, então esta Licença, e seus termos, não se aplicam
                a estas seções quando você distribui-las como trabalhos em
                separado. Mas quando você distribuir as mesmas seções como parte de um
                todo que é trabalho baseado no Programa, a distribuição como um todo
                tem que se enquadrar nos termos desta Licença, cujas permissões para
                outros licenciados se estendem ao todo, portanto também para cada e
                toda parte independente de quem a escreveu.

Desta forma, esta seção não tem a intenção de reclamar direitos os
                contestar seus direitos sobre o trabalho escrito completamente por
                você; ao invés disso, a intenção é a de exercitar o direito de
                controlar a distribuição de trabalhos, derivados ou coletivos,
                baseados no Programa.

Adicionalmente, a mera adição ao Programa de outro trabalho não
                baseado no Programa (ou de trabalho baseado no Programa) em um volume
                de armazenamento ou meio de distribuição não faz o outro trabalho
                parte do escopo desta Licença.

3. Você pode copiar e distribuir o Programa (ou trabalho baseado
                nele, conforme descrito na Seção 2) em código-objeto ou em forma
                executável sob os termos das Seções 1 e 2 acima, desde que você
                faça um dos seguintes:

a) O acompanhe com o código-fonte completo e em forma acessível
                    por máquinas, que tem que ser distribuído sob os termos das Seções
                    1 e 2 acima e em meio normalmente utilizado para o intercâmbio de
                    software; ou,

b) O acompanhe com uma oferta escrita, válida por pelo menos três
                    anos, de fornecer a qualquer um, com um custo não superior ao
                    custo de distribuição física do material, uma cópia do
                    código-fonte completo e em forma acessível por máquinas, que tem
                    que ser distribuído sob os termos das Seções 1 e 2 acima e em meio
                    normalmente utilizado para o intercâmbio de software; ou,

c) O acompanhe com a informação que você recebeu em relação à
                    oferta de distribuição do código-fonte correspondente. (Esta
                    alternativa é permitida somente em distribuição não comerciais, e
                    apenas se você recebeu o programa em forma de código-objeto ou
                    executável, com oferta de acordo com a Subseção b acima.)

O código-fonte de um trabalho corresponde à forma de trabalho
                preferida para se fazer modificações. Para um trabalho em forma
                executável, o código-fonte completo significa todo o código-fonte de
                todos os módulos que ele contém, mais quaisquer arquivos de definição
                de 'interface', mais os 'scripts' utilizados para se controlar a
                compilação e a instalação do executável. Contudo, como exceção
                especial, o código-fonte distribuído não precisa incluir qualquer
                componente normalmente distribuído (tanto em forma original quanto
                binária) com os maiores componentes (o compilador, o 'kernel' etc.) do
                sistema operacional sob o qual o executável funciona, a menos que o
                componente em si acompanhe o executável.

Se a distribuição do executável ou código-objeto é feita através da
                oferta de acesso a cópias de algum lugar, então ofertar o acesso
                equivalente a cópia, do mesmo lugar, do código-fonte equivale à
                distribuição do código-fonte, mesmo que terceiros não sejam compelidos
                a copiar o código-fonte com o código-objeto.

4. Você não pode copiar, modificar, sub-licenciar ou distribuir o
                Programa, exceto de acordo com as condições expressas nesta
                Licença. Qualquer outra tentativa de cópia, modificação,
                sub-licenciamento ou distribuição do Programa não é valida, e
                cancelará automaticamente os direitos que lhe foram fornecidos por
                esta Licença. No entanto, terceiros que de você receberam cópias ou
                direitos, fornecidos sob os termos desta Licença, não terão suas
                licenças terminadas, desde que permaneçam em total concordância com
                ela.

5. Você não é obrigado a aceitar esta Licença já que não a
                assinou. No entanto, nada mais o dará permissão para modificar ou
                distribuir o Programa ou trabalhos derivados deste. Estas ações são
                proibidas por lei, caso você não aceite esta Licença. Desta forma, ao
                modificar ou distribuir o Programa (ou qualquer trabalho derivado do
                Programa), você estará indicando sua total aceitação desta Licença
                para fazê-los, e todos os seus termos e condições para copiar,
                distribuir ou modificar o Programa, ou trabalhos baseados nele.

6. Cada vez que você redistribuir o Programa (ou qualquer trabalho
                baseado nele), os recebedores adquirirão automaticamente do
                licenciador original uma licença para copiar, distribuir ou modificar
                o Programa, sujeitos a estes termos e condições. Você não poderá impor
                aos recebedores qualquer outra restrição ao exercício dos direitos
                então adquiridos. Você não é responsável em garantir a concordância de
                terceiros a esta Licença.

7. Se, em conseqüência de decisões judiciais ou alegações de
                infringimento de patentes ou quaisquer outras razões (não limitadas a
                assuntos relacionados a patentes), condições forem impostas a você
                (por ordem judicial, acordos ou outras formas) e que contradigam as
                condições desta Licença, elas não o livram das condições desta
                Licença. Se você não puder distribuir de forma a satisfazer
                simultaneamente suas obrigações para com esta Licença e para com as
                outras obrigações pertinentes, então como conseqüência você não poderá
                distribuir o Programa. Por exemplo, se uma licença de patente não
                permitirá a redistribuição, livre de 'royalties', do Programa, por
                todos aqueles que receberem cópias direta ou indiretamente de você,
                então a única forma de você satisfazer a ela e a esta Licença seria a
                de desistir completamente de distribuir o Programa.

Se qualquer parte desta seção for considerada inválida ou não
                aplicável em qualquer circunstância particular, o restante da seção se
                aplica, e a seção como um todo se aplica em outras circunstâncias.

O propósito desta seção não é o de induzi-lo a infringir quaisquer
                patentes ou reivindicação de direitos de propriedade outros, ou a
                contestar a validade de quaisquer dessas reivindicações; esta seção
                tem como único propósito proteger a integridade dos sistemas de
                distribuição de software livres, o que é implementado pela prática de
                licenças públicas. Várias pessoas têm contribuído generosamente e em
                grande escala para os software distribuídos usando este sistema, na
                certeza de que sua aplicação é feita de forma consistente; fica a
                critério do autor/doador decidir se ele ou ela está disposto a
                distribuir software utilizando outro sistema, e um licenciado não pode
                impor qualquer escolha.

Esta seção destina-se a tornar bastante claro o que se acredita ser
                conseqüência do restante desta Licença.

8. Se a distribuição e/ou uso do Programa são restringidos em certos
                países por patentes ou direitos autorais, o detentor dos direitos
                autorais original, e que colocou o Programa sob esta Licença, pode
                incluir uma limitação geográfica de distribuição, excluindo aqueles
                países de forma a tornar a distribuição permitida apenas naqueles ou
                entre aqueles países então não excluídos. Nestes casos, esta Licença
                incorpora a limitação como se a mesma constasse escrita nesta Licença.

9. A Free Software Foundation pode publicar versões revisadas e/ou
                novas da Licença Pública Geral de tempos em tempos. Estas novas
                versões serão similares em espírito à versão atual, mas podem diferir
                em detalhes que resolvem novos problemas ou situações.

A cada versão é dada um número distinto. Se o Programa especifica um
                número de versão específico desta Licença que se aplica a ele e a
                'qualquer nova versão', você tem a opção de aceitar os termos e
                condições daquela versão ou de qualquer outra versão publicada pela
                Free Software Foundation. Se o programa não especifica um número de
                versão desta Licença, você pode escolher qualquer versão já publicada
                pela Free Software Foundation.

10. Se você pretende incorporar partes do Programa em outros
                programas livres cujas condições de distribuição são diferentes,
                escreva ao autor e solicite permissão. Para o software que a Free
                Software Foundation detém direitos autorais, escreva à Free Software
                Foundation; às vezes nós permitimos exceções a este caso. Nossa
                decisão será guiada pelos dois objetivos de preservar a condição de
                liberdade de todas as derivações do nosso software livre, e de
                promover o compartilhamento e reutilização de software em aspectos
                gerais.

AUSÊNCIA DE GARANTIAS

11. UMA VEZ QUE O PROGRAMA É LICENCIADO SEM ÔNUS, NÃO HÁ QUALQUER
                GARANTIA PARA O PROGRAMA, NA EXTENSÃO PERMITIDA PELAS LEIS
                APLICÁVEIS. EXCETO QUANDO EXPRESSADO DE FORMA ESCRITA, OS DETENTORES
                DOS DIREITOS AUTORAIS E/OU TERCEIROS DISPONIBILIZAM O PROGRAMA 'NO
                ESTADO', SEM QUALQUER TIPO DE GARANTIAS, EXPRESSAS OU IMPLÍCITAS,
                INCLUINDO, MAS NÃO LIMITADO A, AS GARANTIAS IMPLÍCITAS DE
                COMERCIALIZAÇÃO E AS DE ADEQUAÇÃO A QUALQUER PROPÓSITO. O RISCO TOTAL
                COM A QUALIDADE E DESEMPENHO DO PROGRAMA É SEU. SE O PROGRAMA SE
                MOSTRAR DEFEITUOSO, VOCÊ ASSUME OS CUSTOS DE TODAS AS MANUTENÇÕES,
                REPAROS E CORREÇÕES.

12. EM NENHUMA OCASIÃO, A MENOS QUE EXIGIDO PELAS LEIS APLICÁVEIS OU
                ACORDO ESCRITO, OS DETENTORES DOS DIREITOS AUTORAIS, OU QUALQUER OUTRA
                PARTE QUE POSSA MODIFICAR E/OU REDISTRIBUIR O PROGRAMA CONFORME
                PERMITIDO ACIMA, SERÃO RESPONSABILIZADOS POR VOCÊ POR DANOS, INCLUINDO
                QUALQUER DANO EM GERAL, ESPECIAL, ACIDENTAL OU CONSEQÜENTE,
                RESULTANTES DO USO OU INCAPACIDADE DE USO DO PROGRAMA (INCLUINDO, MAS
                NÃO LIMITADO A, A PERDA DE DADOS OU DADOS TORNADOS INCORRETOS, OU
                PERDAS SOFRIDAS POR VOCÊ OU POR OUTRAS PARTES, OU FALHAS DO PROGRAMA
                AO OPERAR COM QUALQUER OUTRO PROGRAMA), MESMO QUE TAL DETENTOR OU
                PARTE TENHAM SIDO AVISADOS DA POSSIBILIDADE DE TAIS DANOS.

FIM DOS TERMOS E CONDIÇÕES

Como Aplicar Estes Termos aos Seus Novos Programas

Se você desenvolver um novo programa, e quer que ele seja utilizado
                amplamente pelo público, a melhor forma de alcançar este objetivo é
                torná-lo software livre que qualquer um pode redistribuir e alterar,
                sob estes termos.

Para isso, anexe os seguintes avisos ao programa. É mais seguro
                anexá-los logo no início de cada arquivo-fonte para reforçarem mais
                efetivamente a inexistência de garantias; e cada arquivo deve possuir
                pelo menos a linha de 'copyright' e uma indicação de onde o texto
                completo se encontra.

[uma linha que forneça o nome do programa e uma idéia do que ele faz.]
                    Copyright (C) [ano]  [nome do autor]

Este programa é software livre; você pode redistribuí-lo e/ou
                    modificá-lo sob os termos da Licença Pública Geral GNU, conforme
                    publicada pela Free Software Foundation; tanto a versão 2 da
                    Licença como (a seu critério) qualquer versão mais nova.

Este programa é distribuído na expectativa de ser útil, mas SEM
                    QUALQUER GARANTIA; sem mesmo a garantia implícita de
                    COMERCIALIZAÇÃO ou de ADEQUAÇÃO A QUALQUER PROPÓSITO EM
                    PARTICULAR. Consulte a Licença Pública Geral GNU para obter mais
                    detalhes.

Você deve ter recebido uma cópia da Licença Pública Geral GNU
                    junto com este programa; se não, escreva para a Free Software
                    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
                    02111-1307, USA.

Inclua também informações sobre como contactá-lo eletronicamente e por
                carta.

Se o programa é interativo, faça-o mostrar um aviso breve como este,
                ao iniciar um modo interativo:

Gnomovision versão 69, Copyright (C) ano nome do autor
                    O Gnomovision não possui QUALQUER GARANTIA; para obter mais
                    detalhes digite 'show w'. Ele é software livre e você está
                    convidado a redistribui-lo sob certas condições; digite 'show c'
                    para obter detalhes.

Os comandos hipotéticos 'show w' e 'show c' devem mostrar as partes
                apropriadas da Licença Pública Geral. Claro, os comandos que você usar
                podem ser ativados de outra forma que 'show w' e 'show c'; eles podem
                até ser cliques do mouse ou itens de um menu -- o que melhor se
                adequar ao programa.

Você também deve obter do seu empregador (se você trabalha como
                programador) ou escola, se houver, uma 'declaração de ausência de
                direitos autorais' sobre o programa, se necessário. Aqui está um
                exemplo; altere os nomes:

Yoyodyne, Inc., aqui declara a ausência de quaisquer direitos
                   autorais sobre o programa 'Gnomovision' (que executa interpretações
                   em compiladores) escrito por James Hacker.

[assinatura de Ty Coon], 1o. de abril de 1989
                   Ty Con, Vice-presidente

Esta Licença Pública Geral não permite incorporar seu programa em
                programas proprietários. Se seu programa é uma biblioteca de
                sub-rotinas, você deve considerar mais útil permitir ligar aplicações
                proprietárias com a biblioteca. Se isto é o que você deseja, use a
                Licença Pública Geral de Bibliotecas GNU, ao invés desta Licença.

                <form name='terms' action='form_dados.php' method='POST' role='form'>

                            <input type='checkbox' name='lido' onclick='validate()'>Li e concordo com os termos acima.

                        <input class='btn btn-default' type='submit' value='Continuar' disabled='true'>

                </form>


text:
<!DOCTYPE html>

    <meta http-equiv="refresh" content="0;URL=type.U353.html">

Redirecting to type.U353.html...

redpajama_set_name: RedPajamaGithub


text:
package org.simpleflatmapper.sql2o;

import org.simpleflatmapper.jdbc.JdbcMapper;
import org.sql2o.ResultSetHandler;

import java.sql.ResultSet;
import java.sql.SQLException;

public final class SfmResultSetHandler<T> implements ResultSetHandler<T> {
        private final JdbcMapper<T> mapper;

        public SfmResultSetHandler(JdbcMapper<T> mapper) {
            this.mapper = mapper;
        }

        @Override
        public T handle(ResultSet resultSet) throws SQLException {
            return mapper.map(resultSet);
        }
    }


text:
class AddIsMarkedToAtlases < ActiveRecord::Migration
  def change
    add_column :atlases, :is_marked, :boolean, default: false
  end
end


text:
import _debug from 'debug'
import config from './_base'
import environments from './environments'

const debug = _debug('app:config')
debug('Creating configuration.')
debug(`Looking for environment overrides for NODE_ENV "${config.env}".`)

const overrides = environments[config.env]
if (environments[config.env]) {
  debug('Found overrides, applying to default configuration.')
  Object.assign(config, overrides(config))
} else {
  debug('No environment overrides found.')
}

export default config


text:
define([
    'module/index/router',
    'module/index/controller/user',
    'model/user'
], function(
    Router,
    Controller,
    UserModel
) {
    'use strict';

    var routes = {
        'account(/)': 'showAccount',
        '*default': 'showError'
    };

    function userGenerateURL (content)
    {
        if (
            (content instanceof UserModel) &&
            content.isClient()
        ) {
            return '/account';
        }

        return false;
    }

    return Router.extend({
        controller: new Controller(),
        appRoutes: routes,

        generateURL: userGenerateURL
    });
});


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

/**
 * Support for Spring Integration Core.
 */
package com.azure.spring.integration.core.handler;


text:
<?php

namespace Kanboard\Model;

/**
 * Project Daily Column Stats
 *
 * @package  model
 * @author   Frederic Guillot
 */
class ProjectDailyColumnStats extends Base
{
    /**
     * SQL table name
     *
     * @var string
     */
    const TABLE = 'project_daily_column_stats';

    /**
     * Update daily totals for the project and for each column
     *
     * "total" is the number open of tasks in the column
     * "score" is the sum of tasks score in the column
     *
     * @access public
     * @param  integer    $project_id    Project id
     * @param  string     $date          Record date (YYYY-MM-DD)
     * @return boolean
     */
    public function updateTotals($project_id, $date)
    {
        $this->db->startTransaction();
        $this->db->table(self::TABLE)->eq('project_id', $project_id)->eq('day', $date)->remove();

        foreach ($this->getStatsByColumns($project_id) as $column_id => $column) {
            $this->db->table(self::TABLE)->insert(array(
                'day' => $date,
                'project_id' => $project_id,
                'column_id' => $column_id,
                'total' => $column['total'],
                'score' => $column['score'],
            ));
        }

        $this->db->closeTransaction();

        return true;
    }

    /**
     * Count the number of recorded days for the data range
     *
     * @access public
     * @param  integer    $project_id    Project id
     * @param  string     $from          Start date (ISO format YYYY-MM-DD)
     * @param  string     $to            End date
     * @return integer
     */
    public function countDays($project_id, $from, $to)
    {
        return $this->db->table(self::TABLE)
            ->eq('project_id', $project_id)
            ->gte('day', $from)
            ->lte('day', $to)
            ->findOneColumn('COUNT(DISTINCT day)');
    }

    /**
     * Get aggregated metrics for the project within a data range
     *
     * [
     *    ['Date', 'Column1', 'Column2'],
     *    ['2014-11-16', 2, 5],
     *    ['2014-11-17', 20, 15],
     * ]
     *
     * @access public
     * @param  integer    $project_id    Project id
     * @param  string     $from          Start date (ISO format YYYY-MM-DD)
     * @param  string     $to            End date
     * @param  string     $field         Column to aggregate
     * @return array
     */
    public function getAggregatedMetrics($project_id, $from, $to, $field = 'total')
    {
        $columns = $this->column->getList($project_id);
        $metrics = $this->getMetrics($project_id, $from, $to);
        return $this->buildAggregate($metrics, $columns, $field);
    }

    /**
     * Fetch metrics
     *
     * @access public
     * @param  integer    $project_id    Project id
     * @param  string     $from          Start date (ISO format YYYY-MM-DD)
     * @param  string     $to            End date
     * @return array
     */
    public function getMetrics($project_id, $from, $to)
    {
        return $this->db->table(self::TABLE)
            ->eq('project_id', $project_id)
            ->gte('day', $from)
            ->lte('day', $to)
            ->asc(self::TABLE.'.day')
            ->findAll();
    }

    /**
     * Build aggregate
     *
     * @access private
     * @param  array   $metrics
     * @param  array   $columns
     * @param  string  $field
     * @return array
     */
    private function buildAggregate(array &$metrics, array &$columns, $field)
    {
        $column_ids = array_keys($columns);
        $days = array_unique(array_column($metrics, 'day'));
        $rows = array(array_merge(array(e('Date')), array_values($columns)));

        foreach ($days as $day) {
            $rows[] = $this->buildRowAggregate($metrics, $column_ids, $day, $field);
        }

        return $rows;
    }

    /**
     * Build one row of the aggregate
     *
     * @access private
     * @param  array   $metrics
     * @param  array   $column_ids
     * @param  string  $day
     * @param  string  $field
     * @return array
     */
    private function buildRowAggregate(array &$metrics, array &$column_ids, $day, $field)
    {
        $row = array($day);

        foreach ($column_ids as $column_id) {
            $row[] = $this->findValueInMetrics($metrics, $day, $column_id, $field);
        }

        return $row;
    }

    /**
     * Find the value in the metrics
     *
     * @access private
     * @param  array   $metrics
     * @param  string  $day
     * @param  string  $column_id
     * @param  string  $field
     * @return integer
     */
    private function findValueInMetrics(array &$metrics, $day, $column_id, $field)
    {
        foreach ($metrics as $metric) {
            if ($metric['day'] === $day && $metric['column_id'] == $column_id) {
                return $metric[$field];
            }
        }

        return 0;
    }

    /**
     * Get number of tasks and score by columns
     *
     * @access private
     * @param  integer $project_id
     * @return array
     */
    private function getStatsByColumns($project_id)
    {
        $totals = $this->getTotalByColumns($project_id);
        $scores = $this->getScoreByColumns($project_id);
        $columns = array();

        foreach ($totals as $column_id => $total) {
            $columns[$column_id] = array('total' => $total, 'score' => 0);
        }

        foreach ($scores as $column_id => $score) {
            $columns[$column_id]['score'] = (int) $score;
        }

        return $columns;
    }

    /**
     * Get number of tasks and score by columns
     *
     * @access private
     * @param  integer $project_id
     * @return array
     */
    private function getScoreByColumns($project_id)
    {
        $stats = $this->db->table(Task::TABLE)
            ->columns('column_id', 'SUM(score) AS score')
            ->eq('project_id', $project_id)
            ->eq('is_active', Task::STATUS_OPEN)
            ->notNull('score')
            ->groupBy('column_id')
            ->findAll();

        return array_column($stats, 'score', 'column_id');
    }

    /**
     * Get number of tasks and score by columns
     *
     * @access private
     * @param  integer $project_id
     * @return array
     */
    private function getTotalByColumns($project_id)
    {
        $stats = $this->db->table(Task::TABLE)
            ->columns('column_id', 'COUNT(*) AS total')
            ->eq('project_id', $project_id)
            ->in('is_active', $this->getTaskStatusConfig())
            ->groupBy('column_id')
            ->findAll();

        return array_column($stats, 'total', 'column_id');
    }

    /**
     * Get task status to use for total calculation
     *
     * @access private
     * @return array
     */
    private function getTaskStatusConfig()
    {
        if ($this->config->get('cfd_include_closed_tasks') == 1) {
            return array(Task::STATUS_OPEN, Task::STATUS_CLOSED);
        }

        return array(Task::STATUS_OPEN);
    }
}


text:
{% extends 'layout.html' %}

  {% block pageTitle %}
  	State Pension Activation
  {% endblock %}

  {% block content %}

        {% include 'includes/parts/phase-banner.html' %}

Have you ever lived outside of the UK?

          <form action="have-you-lived-abroad" method="post">
            <fieldset class="inline">

                <legend class="visuallyhidden">Have you ever lived outside of the UK?</legend>

                  <input id="lived-outside-yes" type="radio" name="lived-outside-select" value="Yes">
                  Yes

                  <input id="lived-outside-no" type="radio" name="lived-outside-select" value="No">
                  No

            </fieldset>

            <input type="submit" class="button" value="Continue">
          </form>

  {% endblock %}


text:
<mat-card>
  <mat-card-header>

  <mat-card-title>Todd Warren</mat-card-title>
  <mat-card-subtitle>Venture Capitalist, Technologist, Entrepreneurship Educator</mat-card-subtitle>
  </mat-card-header>
<mat-card-content>

Todd is a managing director at Divergent Ventures .   He teaches software entrpereneurship
  at Northwestern University in the Farley Center via a course
  called NUvention Web

Todd teaches classes, makes investments as an angel and through Divergent, and is involved in several non-profits.
    He works on some dev projects for fun and to support his classes.  You can also see particular presentations he has given by clicking the appropriate headings below.

</mat-card-content>
</mat-card>
<mat-accordion>
  <mat-expansion-panel *ngFor="let act of curact">
    <mat-expansion-panel-header class="header-area mat-typography">

{{act}}s

{{act}}es

      </mat-expansion-panel-header>

      <app-activity-grid [activityType]="[act]"></app-activity-grid>

  </mat-expansion-panel>
</mat-accordion>


text:
import pyautogui
import sys
import time
width, height = pyautogui.size()

def main():
	if width != 1920 and height !=1080:
		print "Invalid resolution. Only 1080p currently supported. "
		return
	killerSlash = (1354,986)
	red = (240,0,0)
	gray = (93,90,85)
	black = (0,0,0)
	readpos = (1770,1000)
	slashPos = [(1383,971)]
	ourSlash = slashPos[0]
	while True:
		if pyautogui.pixelMatchesColor(ourSlash[0], ourSlash[1], gray):
			pyautogui.click(x=readpos[0], y=readpos[1])
		elif pyautogui.pixelMatchesColor(ourSlash[0], ourSlash[1], black, tolerance=20):
			while pyautogui.pixelMatchesColor(ourSlash[0], ourSlash[1], black, tolerance=20):
				time.sleep(1)
			if pyautogui.pixelMatchesColor(killerSlash[0], killerSlash[1], red) or pyautogui.pixelMatchesColor(killerSlash[0], killerSlash[1], gray):
				return
			if pyautogui.pixelMatchesColor(killerSlash[0], killerSlash[1], black):
				continue

		time.sleep(1)

if __name__ == '__main__':
  main()


text:
// =================================================================================================
// Copyright 2011 Twitter, Inc.
// -------------------------------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this work except in compliance with the License.
// You may obtain a copy of the License in the LICENSE file, or at:
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =================================================================================================

package com.twitter.common.util;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.logging.Logger;

import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;

import org.apache.commons.lang.builder.HashCodeBuilder;

import com.twitter.common.base.Closure;
import com.twitter.common.base.Closures;
import com.twitter.common.base.ExceptionalSupplier;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.twitter.common.base.MorePreconditions.checkNotBlank;

/**
 * Represents a state machine that is not necessarily a Finite State Machine.
 * The caller may configure the state machine to permit only known state transitions, or to only
 * disallow known state transitions (and permit unknown transitions).
 *
 * @param <T> THe type of objects that the caller uses to represent states.
 *
 * TODO(William Farner): Consider merging the stats-tracking ala PipelineStats into this.
 */
public class StateMachine<T> {
  private static final Logger LOG = Logger.getLogger(StateMachine.class.getName());

  private final String name;

  // Stores mapping from states to the states that the machine is allowed to transition into.
  private final Multimap<T, T> stateTransitions;

  private final Closure<Transition<T>> transitionCallback;
  private final boolean throwOnBadTransition;

  private volatile T currentState;
  private final Lock readLock;
  private final Lock writeLock;

  private StateMachine(String name,
      T initialState,
      Multimap<T, T> stateTransitions,
      Closure<Transition<T>> transitionCallback,
      boolean throwOnBadTransition) {
    this.name = name;
    this.currentState = initialState;
    this.stateTransitions = stateTransitions;
    this.transitionCallback = transitionCallback;
    this.throwOnBadTransition = throwOnBadTransition;

    ReadWriteLock stateLock = new ReentrantReadWriteLock(true /* fair */);
    readLock = stateLock.readLock();
    writeLock = stateLock.writeLock();
  }

  /**
   * Gets the name of this state machine.
   *
   * @return The state machine name.
   */
  public String getName() {
    return name;
  }

  /**
   * Fetches the state that the machine is currently in.
   *
   * @return Current state.
   */
  public T getState() {
    return currentState;
  }

  /**
   * Checks that the current state is the {@code expectedState} and throws if it is not.
   *
   * @param expectedState The expected state
   * @throws IllegalStateException if the current state is not the {@code expectedState}.
   */
  public void checkState(T expectedState) {
    checkState(ImmutableSet.of(expectedState));
  }

  /**
   * Checks that the current state is one of the {@code allowedStates} and throws if it is not.
   *
   * @param allowedStates The allowed states.
   * @throws IllegalStateException if the current state is not the {@code expectedState}.
   */
  public void checkState(Set<T> allowedStates) {
    checkNotNull(allowedStates);
    checkArgument(!allowedStates.isEmpty(), "At least one possible state must be provided.");

    readLock.lock();
    try {
      if (!allowedStates.contains(currentState)) {
        throw new IllegalStateException(
            String.format("In state %s, expected to be in %s.", currentState, allowedStates));
      }
    } finally {
      readLock.unlock();
    }
  }

  /**
   * Executes the supplied {@code work} if the state machine is in the {@code expectedState},
   * postponing any concurrently requested {@link #transition(Object)} until after the execution of
   * the work.
   *
   * @param expectedState The expected state the work should be performed in.
   * @param work The work to perform in the {@code expectedState}.
   * @param <O> The type returned by the unit of work.
   * @param <E> The type of exception that may be thrown by the unit of work.
   * @return The result of the unit of work if the current state is the {@code expectedState}.
   * @throws IllegalStateException if the current state is not the {@code expectedState}.
   * @throws E if the unit of work throws.
   */
  public <O, E extends Exception> O doInState(T expectedState, ExceptionalSupplier<O, E> work)
      throws E {

    checkNotNull(expectedState);
    checkNotNull(work);

    readLock.lock();
    try {
      checkState(expectedState);
      return work.get();
    } finally {
      readLock.unlock();
    }
  }

  /**
   * Transitions the machine into state {@code nextState}.
   *
   * @param nextState The state to move into.
   * @throws IllegalStateTransitionException If the state transition is not allowed.
   * @return {@code true} if the transition was allowed, {@code false} otherwise.
   */
  public boolean transition(T nextState) throws IllegalStateTransitionException {
    boolean transitionAllowed = false;

    T currentCopy = currentState;

    writeLock.lock();
    try {
      if (stateTransitions.containsEntry(currentState, nextState)) {
        currentState = nextState;
        transitionAllowed = true;
      } else if (throwOnBadTransition) {
        throw new IllegalStateTransitionException(
            String.format("State transition from %s to %s is not allowed.", currentState,
                nextState));
      }
    } finally {
      writeLock.unlock();
    }

    transitionCallback.execute(new Transition<T>(currentCopy, nextState, transitionAllowed));
    return transitionAllowed;
  }

  public static class IllegalStateTransitionException extends IllegalStateException {
    public IllegalStateTransitionException(String msg) {
      super(msg);
    }
  }

  /**
   * Convenience method to create a builder object.
   *
   * @param <T> Type of builder to create.
   * @param name Name of the state machine to create a builder for.
   * @return New builder.
   */
  public static <T> Builder<T> builder(String name) {
    return new Builder<T>(name);
  }

  /**
   * A state and its allowed transitions (if any) and (optional) callback.
   *
   * @param <T> State type.
   */
  public static class Rule<T> {
    private final T from;
    private final Set<T> to;
    private final Closure<Transition<T>> callback;

    private Rule(T from) {
      this(from, ImmutableSet.<T>of());
    }

    private Rule(T from, Set<T> to) {
      this(from, to, Closures.<Transition<T>>noop());
    }

    private Rule(T from, Set<T> to, Closure<Transition<T>> callback) {
      this.from = checkNotNull(from);
      this.to = checkNotNull(to);
      this.callback = checkNotNull(callback);
    }

    /**
     * Associates a callback to be triggered after any attempt to transition from this state is
     * made.
     *
     * @param callback Callback to signal.
     * @return A new rule that is identical to this rule, but with the provided
     *     callback
     */
    public Rule<T> withCallback(Closure<Transition<T>> callback) {
      return new Rule<T>(from, to, callback);
    }

    /**
     * A helper class when building a transition rule, to define the allowed transitions.
     *
     * @param <T> State type.
     */
    public static class AllowedTransition<T> {
      private final Rule<T> rule;

      private AllowedTransition(Rule<T> rule) {
        this.rule = rule;
      }

      /**
       * Associates a single allowed transition with this state.
       *
       * @param state Allowed transition state.
       * @return A new rule that identical to the original, but only allowing a transition to the
       *     provided state.
       */
      public Rule<T> to(T state) {
        return new Rule<T>(rule.from, ImmutableSet.<T>of(state), rule.callback);
      }

      /**
       * Associates multiple transitions with this state.
       *
       * @param state An allowed transition state.
       * @param additionalStates Additional states that may be transitioned to.
       * @return A new rule that identical to the original, but only allowing a transition to the
       *     provided states.
       */
      public Rule<T> to(T state, T... additionalStates) {
        return new Rule<T>(rule.from, ImmutableSet.copyOf(Lists.asList(state, additionalStates)));
      }

      /**
       * Allows no transitions to be performed from this state.
       *
       * @return The original rule.
       */
      public Rule<T> noTransitions() {
        return rule;
      }
    }

    /**
     * Creates a new transition rule.
     *
     * @param state State to create and associate transitions with.
     * @param <T> State type.
     * @return A new transition rule builder.
     */
    public static <T> AllowedTransition<T> from(T state) {
      return new AllowedTransition<T>(new Rule<T>(state));
    }
  }

  /**
   * Builder to create a state machine.
   *
   * @param <T>
   */
  public static class Builder<T> {
    private final String name;
    private T initialState;
    private final Multimap<T, T> stateTransitions = HashMultimap.create();
    private final List<Closure<Transition<T>>> transitionCallbacks = Lists.newArrayList();
    private boolean throwOnBadTransition = true;

    public Builder(String name) {
      this.name = checkNotBlank(name);
    }

    /**
     * Sets the initial state for the state machine.
     *
     * @param state Initial state.
     * @return A reference to the builder.
     */
    public Builder<T> initialState(T state) {
      checkNotNull(state);
      initialState = state;
      return this;
    }

    /**
     * Adds a state and its allowed transitions.
     *
     * @param rule The state and transition rule to add.
     * @return A reference to the builder.
     */
    public Builder<T> addState(Rule<T> rule) {
      return addState(rule.callback, rule.from, rule.to);
    }

    /**
     * Adds a state and its allowed transitions.
     * At least one transition state must be added, it is not necessary to explicitly add states
     * that have no allowed transitions (terminal states).
     *
     * @param callback Callback to notify of any transition attempted from the state.
     * @param state State to add.
     * @param transitionStates Allowed transitions from {@code state}.
     * @return A reference to the builder.
     */
    public Builder<T> addState(Closure<Transition<T>> callback, T state,
        Set<T> transitionStates) {
      checkNotNull(callback);
      checkNotNull(state);

      Preconditions.checkArgument(Iterables.all(transitionStates, Predicates.notNull()));

      stateTransitions.putAll(state, transitionStates);

      @SuppressWarnings("unchecked")
      Predicate<Transition<T>> filter = Transition.from(state);
      onTransition(filter, callback);
      return this;
    }

    /**
     * Varargs version of {@link #addState(com.twitter.common.base.Closure, Object, java.util.Set)}.
     *
     * @param callback Callback to notify of any transition attempted from the state.
     * @param state State to add.
     * @param transitionStates Allowed transitions from {@code state}.
     * @return A reference to the builder.
     */
    public Builder<T> addState(Closure<Transition<T>> callback, T state,
        T... transitionStates) {
      Set<T> states = ImmutableSet.copyOf(transitionStates);
      Preconditions.checkArgument(Iterables.all(states, Predicates.notNull()));

      return addState(callback, state, states);
    }

    /**
     * Adds a state and its allowed transitions.
     * At least one transition state must be added, it is not necessary to explicitly add states
     * that have no allowed transitions (terminal states).
     *
     * @param state State to add.
     * @param transitionStates Allowed transitions from {@code state}.
     * @return A reference to the builder.
     */
    public Builder<T> addState(T state, T... transitionStates) {
      return addState(Closures.<Transition<T>>noop(), state, transitionStates);
    }

    private void onTransition(Predicate<Transition<T>> transitionFilter,
        Closure<Transition<T>> handler) {
      onAnyTransition(Closures.filter(transitionFilter, handler));
    }

    /**
     * Adds a callback to be executed for every state transition, including invalid transitions
     * that are attempted.
     *
     * @param handler Callback to notify of transition attempts.
     * @return A reference to the builder.
     */
    public Builder<T> onAnyTransition(Closure<Transition<T>> handler) {
      transitionCallbacks.add(handler);
      return this;
    }

    /**
     * Adds a log message for every state transition that is attempted.
     *
     * @return A reference to the builder.
     */
    public Builder<T> logTransitions() {
      return onAnyTransition(new Closure<Transition<T>>() {
        @Override public void execute(Transition<T> transition) {
          LOG.info(name + " state machine transition " + transition);
        }
      });
    }

    /**
     * Allows the caller to specify whether {@link IllegalStateTransitionException} should be thrown
     * when a bad state transition is attempted (the default behavior).
     *
     * @param throwOnBadTransition Whether an exception should be thrown when a bad state transition
     *     is attempted.
     * @return A reference to the builder.
     */
    public Builder<T> throwOnBadTransition(boolean throwOnBadTransition) {
      this.throwOnBadTransition = throwOnBadTransition;
      return this;
    }

    /**
     * Builds the state machine.
     *
     * @return A reference to the prepared state machine.
     */
    public StateMachine<T> build() {
      Preconditions.checkState(initialState != null, "Initial state must be specified.");
      checkArgument(!stateTransitions.isEmpty(), "No state transitions were specified.");
      return new StateMachine<T>(name,
          initialState,
          stateTransitions,
          Closures.combine(transitionCallbacks),
          throwOnBadTransition);
    }
  }

  /**
   * Representation of a state transition.
   *
   * @param <T> State type.
   */
  public static class Transition<T> {
    private final T from;
    private final T to;
    private final boolean allowed;

    public Transition(T from, T to, boolean allowed) {
      this.from = checkNotNull(from);
      this.to = checkNotNull(to);
      this.allowed = allowed;
    }

    private static <T> Function<Transition<T>, T> from() {
      return new Function<Transition<T>, T>() {
        @Override public T apply(Transition<T> transition) {
          return transition.from;
        }
      };
    }

    private static <T> Function<Transition<T>, T> to() {
      return new Function<Transition<T>, T>() {
        @Override public T apply(Transition<T> transition) {
          return transition.to;
        }
      };
    }

    private static <T> Predicate<Transition<T>> oneSideFilter(
        Function<Transition<T>, T> extractor, final T... states) {
      checkArgument(Iterables.all(Arrays.asList(states), Predicates.notNull()));

      return Predicates.compose(Predicates.in(ImmutableSet.copyOf(states)), extractor);
    }

    /**
     * Creates a predicate that returns {@code true} for transitions from the given states.
     *
     * @param states States to filter on.
     * @param <T> State type.
     * @return A from-state filter.
     */
    public static <T> Predicate<Transition<T>> from(final T... states) {
      return oneSideFilter(Transition.<T>from(), states);
    }

    /**
     * Creates a predicate that returns {@code true} for transitions to the given states.
     *
     * @param states States to filter on.
     * @param <T> State type.
     * @return A to-state filter.
     */
    public static <T> Predicate<Transition<T>> to(final T... states) {
      return oneSideFilter(Transition.<T>to(), states);
    }

    /**
     * Creates a predicate that returns {@code true} for a specific state transition.
     *
     * @param from From state.
     * @param to To state.
     * @param <T> State type.
     * @return A state transition filter.
     */
    public static <T> Predicate<Transition<T>> transition(final T from, final T to) {
      @SuppressWarnings("unchecked")
      Predicate<Transition<T>> fromFilter = from(from);
      @SuppressWarnings("unchecked")
      Predicate<Transition<T>> toFilter = to(to);
      return Predicates.and(fromFilter, toFilter);
    }

    public T getFrom() {
      return from;
    }

    public T getTo() {
      return to;
    }

    public boolean isAllowed() {
      return allowed;
    }

    /**
     * Checks whether this transition represents a state change, which means that the 'to' state is
     * not equal to the 'from' state, and the transition is allowed.
     *
     * @return {@code true} if the state was changed, {@code false} otherwise.
     */
    public boolean isValidStateChange() {
      return isAllowed() && !from.equals(to);
    }

    @Override
    public boolean equals(Object o) {
      if (!(o instanceof Transition)) {
        return false;
      }

      if (o == this) {
        return true;
      }

      Transition<?> other = (Transition) o;
      return from.equals(other.from) && to.equals(other.to);
    }

    @Override
    public int hashCode() {
      return new HashCodeBuilder()
          .append(from)
          .append(to)
          .toHashCode();
    }

    @Override
    public String toString() {
      String str = from.toString() + " -> " + to.toString();
      if (!isAllowed()) {
        str += " (not allowed)";
      }
      return str;
    }
  }
}