text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Support.Wearable.Views;
using Android.Views;
using Android.Widget;

namespace SimpleWeather.Droid.Wear.Helpers
{
    public class AcceptDenyDialogBuilder : IDisposable
    {
        private Context mContext;
        private String Message;
        private EventHandler<DialogClickEventArgs> NegativeButtonEvent;
        private EventHandler<DialogClickEventArgs> PositiveButtonEvent;
        private IDialogInterfaceOnClickListener clickListener;

        public void Dispose()
        {
            clickListener.Dispose();
            GC.SuppressFinalize(this);
        }

        public AcceptDenyDialogBuilder(Context context)
        {
            mContext = context;
            clickListener = new AcceptDenyDialogListener(this);
        }

        private void Apply(AcceptDenyDialog dialog)
        {
            dialog.SetMessage(Message);
            dialog.SetPositiveButton(clickListener);
            dialog.SetNegativeButton(clickListener);
        }

        public AcceptDenyDialogBuilder SetMessage(int resId)
        {
            Message = mContext.GetString(resId);
            return this;
        }

        public AcceptDenyDialogBuilder SetPositiveButton(EventHandler<DialogClickEventArgs> handler)
        {
            PositiveButtonEvent = handler;
            return this;
        }

        public AcceptDenyDialogBuilder SetNegativeButton(EventHandler<DialogClickEventArgs> handler)
        {
            NegativeButtonEvent = handler;
            return this;
        }

        public AcceptDenyDialog Create()
        {
            var dialog = new AcceptDenyDialog(mContext);
            dialog.Create();
            Apply(dialog);
            return dialog;
        }

        public AcceptDenyDialog Show()
        {
            var dialog = this.Create();
            dialog.Show();
            return dialog;
        }

        private class AcceptDenyDialogListener : Java.Lang.Object, IDialogInterfaceOnClickListener
        {
            private AcceptDenyDialogBuilder builder;

            public AcceptDenyDialogListener(AcceptDenyDialogBuilder builder)
            {
                this.builder = builder;
            }

            public void OnClick(IDialogInterface dialog, int which)
            {
                switch (which)
                {
                    case (int)DialogButtonType.Positive:
                        builder.PositiveButtonEvent?.Invoke(dialog, new DialogClickEventArgs(which));
                        break;
                    case (int)DialogButtonType.Negative:
                        builder.NegativeButtonEvent?.Invoke(dialog, new DialogClickEventArgs(which));
                        break;
                    case (int)DialogButtonType.Neutral:
                        break;
                }
            }
        }
    }
}


text:
var express = require('express');
var mongoose = require('mongoose');
var db = mongoose.connect('mongodb://localhost/foodTruckAPI');
var Truck = require('../models/truckModel');
var bodyParser = require('body-parser');
// the Router method returns an instance which
// can be mounted as middle-ware
var router = express.Router();

router.use(bodyParser.urlencoded({ extended: true }));
router.use(bodyParser.json());

router.route('/')
	.get(function (request, response) {
		Truck.find(function (error, trucks) {
			if (error) {
				response.status(500).send(error);
			} else {
				response.json(trucks);
			}
		});
	})
	.post(function (request, response) {
		var truck = new Truck(request.body);
		truck.save(function (error) {
			if (error) {
				response.status(500).send(error);
			} else {
				response.status(201).send(truck);
			}
		});
	});

router.route('/:id')
	.get(function (request, response) {
		Truck.findById(request.params.id, function (error, truck) {
			if (error) {
				response.status(500).send(error);
			} else {
				response.json(truck);
			}
		});
	})
	.delete(function (request, response) {
		Truck.findById(request.params.id, function (error, truck) {
			if (error) {
				response.status(500).send(error);
			} else {
				truck.remove(function (error) {
					if (error) {
						response.status(500).send(error);
					} else {
						response.status(204).send('removed');
					}
				});
			}
		});
	})
	.put(function (request, response) {
		Truck.findById(request.params.id, function (error, truck) {
			if (error) {
				response.status(500).send(error);
			} else {
				truck.name = request.body.title;
				truck.foodType = request.body.foodType;
				truck.schedule = request.body.schedule;
				truck.payment = request.body.payment;
				truck.description = request.body.description;
				truck.website = request.body.website;
				truck.Facebook = request.body.Facebook;
				truck.Twitter = request.body.read;
				truck.save(function (error) {
					if (error) {
						response.status(500).send(error);
					} else {
						response.send(book);
					}
				});
			}
		});
	});

module.exports = router;

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

  <meta charset="UTF-8">
  <link href="http://gmpg.org/xfn/11" rel="profile">

  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1">

  <title>

      DataSorcery · Quando a razão encontra...

  </title>

  <link rel="stylesheet" href="/public/css/poole.css">
  <link rel="stylesheet" href="/public/css/syntax.css">

  <link rel="apple-touch-icon-precomposed" sizes="144x144" href="/public/apple-touch-icon-precomposed.png">
  <link rel="shortcut icon" href="/public/favicon.ico">

  <link rel="alternate" type="application/atom+xml" title="DataSorcery" href="/atom.xml">

          DataSorcery

            Sobre

            Arquivo

            Feed

        Um Nerd e a Poesia

    <time datetime="2016-03-08T00:00:00-03:00" class="post-date">08 Mar 2016</time>

Recentemente passei a admirar um gênero artístico que sempre foi um mistério pra mim: poesia! É bem curioso pois, apesar de sempre estar envolvido com música, raramente me preocupava com a poesia. Por vezes tenho me surpreendido com o significado de algumas músicas que já ouvi milhões de vezes mas que, só agora, realmente entendi…

Por exemplo: você sabe sobre o que o Taiguara está falando na música Hoje? Tente ouvir e descobrir. Depois compare com a minha resposta no final deste post!

Uma outra coisa com a qual tenho me divertido bastante é fazer traduções. Ler os originais é certamente muito legal, mas tentar criar uma tradução que leve alguém que nunca leu o original entender não só o sentido, mas também as figuras artísticas utilizadas pelo autor, é uma experiência muito bacana!

No meu recente passeio pelo gênero descobri o poeta grego C P Cavafy que, dentre outros temas, escreve sobre as virtudes estóicas (hum, estoicismo pode ser um tema interessante para um outro post). O poema abaixo se endereça ao general romano Marco Antônio após sua derrota na batalha contra Otávio, onde perdeu Alexandria e foi abandonado por Baco, o deus que até então o havia protegido. O original está escrito em grego, mas minha versão foi feita a partir da tradução original para o inglês presente neste site.

Enjoy!

O Deus Abandona Antônio

Quando abruptamente, à meia noite, você ouve

uma invisível procissão passando

com música requintada, vozes,

não lamente sua sorte que está falhando agora,

trabalho que não deu certo, seus planos

todos provando-se enganosos - não lamente-os inutilmente.

Como alguém há muito tempo preparado, e agraciado com coragem,

diga adeus a ela, a Alexandria que está partindo.

Sobretudo, não se engane, não diga

que era um sonho, seus ouvidos o enganaram:

não se degrade com esperanças vazias como estas.

Como alguém há muito preparado, e agraciado com coragem,

como é certo para você que se provou digno deste tipo de cidade,

vá firmemente a janela

e ouça com grande emoção, mas não

com o choramingo, o rogo de um covarde;

ouça - seu deleite final - as vozes,

à música requintada desta estranha procissão

e diga adeus a ela, para a Alexandria que você está perdendo.

The God Abandons Antony

When suddenly, at midnight, you hear

an invisible procession going by

with exquisite music, voices,

don't mourn your luck that's failing now,

work gone wrong, your plans

all proving deceptive—don't mourn them uselessly.

As one long prepared, and graced with courage,

say goodbye to her, the Alexandria that is leaving.

Above all, don't fool yourself, don't say

it was a dream, your ears deceived you:

don't degrade yourself with empty hopes like these.

As one long prepared, and graced with courage,

as is right for you who proved worthy of this kind of city,

go firmly to the window

and listen with deep emotion, but not

with the whining, the pleas of a coward;

listen—your final delectation—to the voices,

to the exquisite music of that strange procession,

and say goodbye to her, to the Alexandria you are losing.

C YA

PS.: Para mim, a música Hoje fala sobre a Juventude. O que vc acha?

    Escreva para @costa_2_0

    Anterior

      Próximo

          © <time datetime="2016-03-28T14:29:39-03:00">2016</time>. Todos os direitos reservados.


text:
Tutorials
*********

Jupyter Notebook Tutorials illustrating how to use core functionality of nltools

.. toctree::
  :maxdepth: 2

    How to use Brain_Data Class Tutorial  <http://nbviewer.jupyter.org/github/ljchang/neurolearn/blob/master/scripts/NLTools_Brain_Data_Class_Tutorial.ipynb>
    Analysis Tutorial  <http://nbviewer.ipython.org/github/ljchang/neurolearn/blob/master/scripts/Chang_ML_fMRI_Tutorial.ipynb>


text:
package com.streamsets.lib.security.http;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.streamsets.datacollector.util.Configuration;
import com.streamsets.pipeline.api.impl.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class RemoteSSOService extends AbstractSSOService {
  private static final Logger LOG = LoggerFactory.getLogger(RemoteSSOService.class);

  private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

  public static final String DPM_BASE_URL_CONFIG = "dpm.base.url";
  public static final String DPM_BASE_URL_DEFAULT = "http://localhost:18631";

  public static final String SECURITY_SERVICE_APP_AUTH_TOKEN_CONFIG = CONFIG_PREFIX + "appAuthToken";
  public static final String SECURITY_SERVICE_COMPONENT_ID_CONFIG = CONFIG_PREFIX + "componentId";
  public static final String SECURITY_SERVICE_COMPONENT_TYPE_CONFIG = CONFIG_PREFIX + "componentType";
  public static final String DPM_ENABLED = CONFIG_PREFIX + "enabled";
  public static final boolean DPM_ENABLED_DEFAULT = false;

  public static final String CONTENT_TYPE = "Content-Type";
  public static final String ACCEPT = "Accept";
  public static final String APPLICATION_JSON = "application/json";

  private String userAuthUrl;
  private String appAuthUrl;
  private String appToken;
  private String componentId;

  @Override
  public void setDelegateTo(SSOService ssoService) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void setConfiguration(Configuration conf) {
    super.setConfiguration(conf);
    String dpmBaseUrl = getValidURL(conf.get(DPM_BASE_URL_CONFIG, DPM_BASE_URL_DEFAULT));
    String baseUrl = dpmBaseUrl + "security";

    Utils.checkArgument(
        baseUrl.toLowerCase().startsWith("http:") || baseUrl.toLowerCase().startsWith("https:"),
        Utils.formatL("Security service base URL must be HTTP/HTTPS '{}'", baseUrl)
    );
    if (baseUrl.toLowerCase().startsWith("http://")) {
      LOG.warn("Security service base URL is not secure '{}'", baseUrl);
    }
    setLoginPageUrl(baseUrl + "/login");
    setLogoutUrl(baseUrl + "/_logout");
    userAuthUrl = baseUrl + "/rest/v1/validateAuthToken/user";
    appAuthUrl = baseUrl + "/rest/v1/validateAuthToken/component";
    appToken = conf.get(SECURITY_SERVICE_APP_AUTH_TOKEN_CONFIG, null);
  }

  public void setComponentId(String componentId) {
    Utils.checkArgument(componentId != null && !componentId.trim().isEmpty(), "Component ID cannot be NULL or empty");
    this.componentId = componentId.trim();
  }

  public void setApplicationAuthToken(String appToken) {
    this.appToken = (appToken != null) ? appToken.trim() : null;
  }

  HttpURLConnection createAuthConnection(String url) throws IOException {
    return (HttpURLConnection) new URL(url).openConnection();
  }

  HttpURLConnection getAuthConnection(String method, String url) throws IOException {
    HttpURLConnection conn = createAuthConnection(url);
    conn.setRequestMethod(method);
    switch (method) {
      case "POST":
      case "PUT":
        conn.setDoOutput(true);
      case "GET":
        conn.setDoInput(true);
    }
    conn.setUseCaches(false);
    conn.setConnectTimeout(5000);
    conn.setReadTimeout(5000);
    conn.setRequestProperty(CONTENT_TYPE, APPLICATION_JSON);
    conn.setRequestProperty(ACCEPT, APPLICATION_JSON);
    conn.setRequestProperty(SSOConstants.X_REST_CALL, "-");
    conn.setRequestProperty(SSOConstants.X_APP_AUTH_TOKEN, appToken);
    conn.setRequestProperty(SSOConstants.X_APP_COMPONENT_ID, componentId);
    return conn;
  }

  <T> T doAuthRestCall(String url, Object uploadData, Class<T> responseType) {
    T ret = null;
    String method = (uploadData == null) ? "GET" : "POST";
    try {
      HttpURLConnection conn = getAuthConnection(method, url);
      if (uploadData != null) {
        OutputStream os = conn.getOutputStream();
        OBJECT_MAPPER.writeValue(os, uploadData);
      }
      if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
        ret = (T) OBJECT_MAPPER.readValue(conn.getInputStream(), responseType);
      } else {
        LOG.warn("Security service HTTP error '{}': {}", conn.getResponseCode(), conn.getResponseMessage());
      }
    } catch (IOException ex) {
      LOG.warn("Security service error: {}", ex.toString(), ex);
    }
    return ret;
  }

  protected SSOPrincipal validateUserTokenWithSecurityService(String authToken) {
    ValidateUserAuthTokenJson authTokenJson = new ValidateUserAuthTokenJson();
    authTokenJson.setAuthToken(authToken);
    SSOPrincipalJson principal = doAuthRestCall(userAuthUrl, authTokenJson, SSOPrincipalJson.class);
    if (principal != null) {
      principal.setTokenStr(authToken);
      principal.lock();
      LOG.debug("Validated user auth token for '{}'", principal.getPrincipalId());
    } else {
      LOG.warn("Failed to validate user token '{}'", authToken);
    }
    return principal;
  }

  protected SSOPrincipal validateAppTokenWithSecurityService(String authToken, String componentId) {
    ValidateComponentAuthTokenJson authTokenJson = new ValidateComponentAuthTokenJson();
    authTokenJson.setComponentId(componentId);
    authTokenJson.setAuthToken(authToken);
    SSOPrincipalJson principal = doAuthRestCall(appAuthUrl, authTokenJson, SSOPrincipalJson.class);
    if (principal != null) {
      principal.setTokenStr(authToken);
      principal.lock();
      LOG.debug("Validated app auth token for '{}'", principal.getPrincipalId());
    } else {
      LOG.warn("Failed to validate app token '{}'", authToken);
    }
    return principal;
  }

  public static String getValidURL(String url) {
    if (!url.endsWith("/")) {
      url += "/";
    }
    return url;
  }

}


text:
using System.Collections.Generic;
using Dufry.Comissoes.Domain.Entities.Validations;
using Dufry.Comissoes.Domain.Interfaces.Validation;
using Dufry.Comissoes.Domain.Validation;

namespace Dufry.Comissoes.Domain.Entities
{
    public partial class Filial
    {
        public int Id_Filial { get; set; }
        public int Id_Empresa { get; set; }
        public int Id_Cidade { get; set; }
        public string CodigoFilialAlternate { get; set; }
        public string NomeFilial { get; set; }
    }
}


text:
layout: post
title:  "NUnit 3.9 Released"
date:   2017-11-10 12:00:00 -0000
categories: news update nunit
---
This release addresses numerous parallelization issues that were introduced in 3.8 when method level parallelization was added. Most of the parallelization issues resolved were tests never completing when using some combinations of parallel tests and `ApartmentState` not being properly applied to tests in all cases.

You may download NUnit 3.9 from [Github](https://github.com/nunit/nunit/releases). See the [release notes](https://github.com/nunit/docs/wiki/Release-Notes) for more information.