CONECTAR COM MYSQL – PYTHON

import mysql.connector

mydb = mysql.connector.conect(
host=”localhost”,
user=”SeuUsuario”,
passwd=”SuaSenha”,
database=’SeuBanco’
)
mycursor = mydb.cursor()

mycursor.execute(“SELECT * FROM customers”)
# or
# mycursor.execute(“SELECT name, address FROM customers”)
myresult = mycursor.fetchall()
for x in myresult:
print(x)

SELECIONAR NÚMEROS EM ARRAY DE STRINGS – PYTHON

Primeiramente fazemos o carregamento da biblioteca “re” em seguida atribuímos à variável text, a cadeia de caracteres contida dentro das aspas duplas. Na linha abaixo, atribuímos à variável numbers, o retorno do comando re.findall 

 

import re

text = "Phi@#$%3.14kjlw0xd65adfa01ckv0jle-19&*ghn334"
numbers = re.findall(r'\d+', text)

print(numbers)

Construindo um classificador de texto no Spark Shell do Mahout

Construindo um classificador de texto no Spark Shell do Mahout

Este tutorial o guiará pelas etapas usadas para treinar um modelo Naive Bayes Multinomial e criar um classificador de texto baseado nesse modelo usando o mahout spark-shell.

Pré-requisitos

Este tutorial pressupõe que você tenha suas variáveis ​​de ambiente do Spark configuradas para a mahout spark-shellvisualização: Reprodução com o Shell do Mahout . Além disso, assumimos que o Mahout está sendo executado no modo de cluster (ou seja, com a MAHOUT_LOCALvariável de ambiente não definida ), conforme estaremos lendo e gravando no HDFS.

Download e vetorização do conjunto de dados da Wikipedia

A partir de Mahout v. 0.10.0, ainda estamos dependentes das versões MapReduce de mahout seqwikimahout seq2sparsepara extrair e vetorizar nosso texto. Uma implementação Spark do seq2sparse está em andamento para o Mahout v. 0.11. No entanto, para baixar o conjunto de dados da Wikipedia, extrair os corpos da documentação, rotular cada documento e vetorizar o texto em vetores TF-IDF, podemos executar o exemplo de wikipedia-classifier.sh de forma simples .

Please select a number to choose the corresponding task to run
1. CBayes (may require increased heap space on yarn)
2. BinaryCBayes
3. clean -- cleans up the work area in /tmp/mahout-work-wiki
Enter your choice :

Digite (2). Isso fará o download de um grande dump XML recente do banco de dados da Wikipedia, em um /tmp/mahout-work-wikidiretório, descompactá-lo e colocá-lo no HDFS. Ele executará um trabalho MapReduce para analisar o conjunto da wikipedia , extraindo e rotulando apenas páginas com tags de categoria para [Estados Unidos] e [Reino Unido] (documentos ~ 11600). Em seguida, ele será executado mahout seq2sparsepara converter os documentos em vetores TF-IDF. O script também irá compilar e testar um modelo Naive Bayes usando o MapReduce . Quando estiver concluído, você verá uma matriz de confusão na tela. Para este tutorial, vamos ignorar o modelo MapReduce e construir um novo modelo usando o Spark baseado na saída de texto vetorizado por seq2sparse.

Começando

Inicie o mahout spark-shell. Há um script de exemplo: spark-document-classifier.mscala(.mscala denota um script Mahout-Scala que pode ser executado de forma semelhante a um script R). Nós estaremos percorrendo este script para este tutorial, mas se você quisesse simplesmente executar o script, você poderia simplesmente emitir o comando:

mahout> :load /path/to/mahout/examples/bin/spark-document-classifier.mscala

Por enquanto, vamos desmontar o roteiro, peça por peça. Você pode recortar e colar os seguintes blocos de código no mahout spark-shell.

Importações

Nossas importações de Mahout Naive Bayes:

import org.apache.mahout.classifier.naivebayes._
import org.apache.mahout.classifier.stats._
import org.apache.mahout.nlp.tfidf._

Importações Hadoop necessárias para ler o nosso dicionário:

import org.apache.hadoop.io.Text
import org.apache.hadoop.io.IntWritable
import org.apache.hadoop.io.LongWritable

Leia em nosso conjunto completo do HDFS como vetorizado por seq2sparse em classify-wikipedia.sh

val pathToData = "/tmp/mahout-work-wiki/"
val fullData = drmDfsRead(pathToData + "wikipediaVecs/tfidf-vectors")

Extrair a categoria de cada observação e agregar essas observações por categoria

val (labelIndex, aggregatedObservations) = SparkNaiveBayes.extractLabelsAndAggregateObservations(
                                                             fullData)

Construa um modelo Muitinomial Naive Bayes e autoteste no conjunto de treinamento

val model = SparkNaiveBayes.train(aggregatedObservations, labelIndex, false)
val resAnalyzer = SparkNaiveBayes.test(model, fullData, false)
println(resAnalyzer)

imprimir o ResultAnalyzermostrará a matriz de confusão.

Leia no dicionário e conte a frequência de documentos do HDFS

val dictionary = sdc.sequenceFile(pathToData + "wikipediaVecs/dictionary.file-0",
                                  classOf[Text],
                                  classOf[IntWritable])
val documentFrequencyCount = sdc.sequenceFile(pathToData + "wikipediaVecs/df-count",
                                              classOf[IntWritable],
                                              classOf[LongWritable])

// setup the dictionary and document frequency count as maps
val dictionaryRDD = dictionary.map { 
                                case (wKey, wVal) => wKey.asInstanceOf[Text]
                                                         .toString() -> wVal.get() 
                                   }
                                   
val documentFrequencyCountRDD = documentFrequencyCount.map {
                                        case (wKey, wVal) => wKey.asInstanceOf[IntWritable]
                                                                 .get() -> wVal.get() 
                                                           }

val dictionaryMap = dictionaryRDD.collect.map(x => x._1.toString -> x._2.toInt).toMap
val dfCountMap = documentFrequencyCountRDD.collect.map(x => x._1.toInt -> x._2.toLong).toMap

Definir uma função para tokenize e vectorize o novo texto usando nosso dicionário atual

Para este exemplo simples, nossa função vectorizeDocument(...)irá converter um novo documento em unigramas usando métodos nativos de String Java e vetorizar usando nossas frequências de dicionário e documento. Você também pode usar um analisador Lucene para bigramas, trigramas, etc. e integrar o Apache Tika para extrair texto de diferentes tipos de documentos (PDF, PPT, XLS, etc.). Aqui, no entanto, vamos mantê-lo simples, separando e tokenizing nosso texto usando regexs e métodos nativos de String.

def vectorizeDocument(document: String,
                        dictionaryMap: Map[String,Int],
                        dfMap: Map[Int,Long]): Vector = {
    val wordCounts = document.replaceAll("[^\\p{L}\\p{Nd}]+", " ")
                                .toLowerCase
                                .split(" ")
                                .groupBy(identity)
                                .mapValues(_.length)         
    val vec = new RandomAccessSparseVector(dictionaryMap.size)
    val totalDFSize = dfMap(-1)
    val docSize = wordCounts.size
    for (word <- wordCounts) {
        val term = word._1
        if (dictionaryMap.contains(term)) {
            val tfidf: TermWeight = new TFIDF()
            val termFreq = word._2
            val dictIndex = dictionaryMap(term)
            val docFreq = dfCountMap(dictIndex)
            val currentTfIdf = tfidf.calculate(termFreq,
                                               docFreq.toInt,
                                               docSize,
                                               totalDFSize.toInt)
            vec.setQuick(dictIndex, currentTfIdf)
        }
    }
    vec
}

Configure nosso classificador

val labelMap = model.labelIndex
val numLabels = model.numLabels
val reverseLabelMap = labelMap.map(x => x._2 -> x._1)

// instantiate the correct type of classifier
val classifier = model.isComplementary match {
    case true => new ComplementaryNBClassifier(model)
    case _ => new StandardNBClassifier(model)
}

Definir uma função argmax

O rótulo com a pontuação mais alta ganha a classificação de um determinado documento.

def argmax(v: Vector): (Int, Double) = {
    var bestIdx: Int = Integer.MIN_VALUE
    var bestScore: Double = Integer.MIN_VALUE.asInstanceOf[Int].toDouble
    for(i <- 0 until v.size) {
        if(v(i) > bestScore){
            bestScore = v(i)
            bestIdx = i
        }
    }
    (bestIdx, bestScore)
}

Defina nosso classificador de vetores TF (-IDF)

def classifyDocument(clvec: Vector) : String = {
    val cvec = classifier.classifyFull(clvec)
    val (bestIdx, bestScore) = argmax(cvec)
    reverseLabelMap(bestIdx)
}

Dois exemplos de artigos de notícias: Futebol dos Estados Unidos e Futebol do Reino Unido

// A random United States football article
// http://www.reuters.com/article/2015/01/28/us-nfl-superbowl-security-idUSKBN0L12JR20150128
val UStextToClassify = new String("(Reuters) - Super Bowl security officials acknowledge" +
    " the NFL championship game represents a high profile target on a world stage but are" +
    " unaware of any specific credible threats against Sunday's showcase. In advance of" +
    " one of the world's biggest single day sporting events, Homeland Security Secretary" +
    " Jeh Johnson was in Glendale on Wednesday to review security preparations and tour" +
    " University of Phoenix Stadium where the Seattle Seahawks and New England Patriots" +
    " will battle. Deadly shootings in Paris and arrest of suspects in Belgium, Greece and" +
    " Germany heightened fears of more attacks around the world and social media accounts" +
    " linked to Middle East militant groups have carried a number of threats to attack" +
    " high-profile U.S. events. There is no specific credible threat, said Johnson, who" + 
    " has appointed a federal coordination team to work with local, state and federal" +
    " agencies to ensure safety of fans, players and other workers associated with the" + 
    " Super Bowl. I'm confident we will have a safe and secure and successful event." +
    " Sunday's game has been given a Special Event Assessment Rating (SEAR) 1 rating, the" +
    " same as in previous years, except for the year after the Sept. 11, 2001 attacks, when" +
    " a higher level was declared. But security will be tight and visible around Super" +
    " Bowl-related events as well as during the game itself. All fans will pass through" +
    " metal detectors and pat downs. Over 4,000 private security personnel will be deployed" +
    " and the almost 3,000 member Phoenix police force will be on Super Bowl duty. Nuclear" +
    " device sniffing teams will be deployed and a network of Bio-Watch detectors will be" +
    " set up to provide a warning in the event of a biological attack. The Department of" +
    " Homeland Security (DHS) said in a press release it had held special cyber-security" +
    " and anti-sniper training sessions. A U.S. official said the Transportation Security" +
    " Administration, which is responsible for screening airline passengers, will add" +
    " screeners and checkpoint lanes at airports. Federal air marshals, behavior detection" +
    " officers and dog teams will help to secure transportation systems in the area. We" +
    " will be ramping it (security) up on Sunday, there is no doubt about that, said Federal"+
    " Coordinator Matthew Allen, the DHS point of contact for planning and support. I have" +
    " every confidence the public safety agencies that represented in the planning process" +
    " are going to have their best and brightest out there this weekend and we will have" +
    " a very safe Super Bowl.")

// A random United Kingdom football article
// http://www.reuters.com/article/2015/01/26/manchester-united-swissquote-idUSL6N0V52RZ20150126
val UKtextToClassify = new String("(Reuters) - Manchester United have signed a sponsorship" +
    " deal with online financial trading company Swissquote, expanding the commercial" +
    " partnerships that have helped to make the English club one of the richest teams in" +
    " world soccer. United did not give a value for the deal, the club's first in the sector," +
    " but said on Monday it was a multi-year agreement. The Premier League club, 20 times" +
    " English champions, claim to have 659 million followers around the globe, making the" +
    " United name attractive to major brands like Chevrolet cars and sportswear group Adidas." +
    " Swissquote said the global deal would allow it to use United's popularity in Asia to" +
    " help it meet its targets for expansion in China. Among benefits from the deal," +
    " Swissquote's clients will have a chance to meet United players and get behind the scenes" +
    " at the Old Trafford stadium. Swissquote is a Geneva-based online trading company that" +
    " allows retail investors to buy and sell foreign exchange, equities, bonds and other asset" +
    " classes. Like other retail FX brokers, Swissquote was left nursing losses on the Swiss" +
    " franc after Switzerland's central bank stunned markets this month by abandoning its cap" +
    " on the currency. The fallout from the abrupt move put rival and West Ham United shirt" +
    " sponsor Alpari UK into administration. Swissquote itself was forced to book a 25 million" +
    " Swiss francs ($28 million) provision for its clients who were left out of pocket" +
    " following the franc's surge. United's ability to grow revenues off the pitch has made" +
    " them the second richest club in the world behind Spain's Real Madrid, despite a" +
    " downturn in their playing fortunes. United Managing Director Richard Arnold said" +
    " there was still lots of scope for United to develop sponsorships in other areas of" +
    " business. The last quoted statistics that we had showed that of the top 25 sponsorship" +
    " categories, we were only active in 15 of those, Arnold told Reuters. I think there is a" +
    " huge potential still for the club, and the other thing we have seen is there is very" +
    " significant growth even within categories. United have endured a tricky transition" +
    " following the retirement of manager Alex Ferguson in 2013, finishing seventh in the" +
    " Premier League last season and missing out on a place in the lucrative Champions League." +
    " ($1 = 0.8910 Swiss francs) (Writing by Neil Maidment, additional reporting by Jemima" + 
    " Kelly; editing by Keith Weir)")

Vetorize e classifique nossos documentos

val usVec = vectorizeDocument(UStextToClassify, dictionaryMap, dfCountMap)
val ukVec = vectorizeDocument(UKtextToClassify, dictionaryMap, dfCountMap)

println("Classifying the news article about superbowl security (united states)")
classifyDocument(usVec)

println("Classifying the news article about Manchester United (united kingdom)")
classifyDocument(ukVec)

Amarre tudo em um novo método para classificar o texto

def classifyText(txt: String): String = {
    val v = vectorizeDocument(txt, dictionaryMap, dfCountMap)
    classifyDocument(v)
}

Agora podemos simplesmente chamar nosso método classifyText (…) em qualquer String

classifyText("Hello world from Queens")
classifyText("Hello world from London")

Persistência do modelo

Você pode salvar o modelo no HDFS:

model.dfsWrite("/path/to/model")

E recupere-o com:

val model =  NBModel.dfsRead("/path/to/model")

O modelo treinado agora pode ser incorporado em um aplicativo externo.

 

Fonte:  http://mahout.apache.org/docs/latest/tutorials/samsara/classify-a-doc-from-the-shell.html

Construindo uma aplicação Ionic CRUD com Firestore

O Firestore é o novo banco de dados do Firebase. É um banco de dados orientado a documentos NoSQL para desenvolvimento móvel e web.

Ele é projetado para armazenar e sincronizar dados de aplicativos em escala global com facilidade. Algumas de suas principais características incluem:

  • Documentos e Coleções com consultas poderosas.
  • Acesso off-line ao WEB SDK.
  • Sincronização de dados em tempo real.

Hoje vamos aprender a integrar o Firestore com o Ionic para criar um fluxo de trabalho CRUD. Este aplicativo de amostra mostrará a você como:

  • Mostrando uma lista de itens do seu banco de dados ( que no Firestore é chamado exibindo uma coleção de documentos ).
  • Criando um novo item e adicionando-o à lista.
  • Navegar para a página de detalhes desse item.
  • Excluindo um item da nossa lista.

captura de tela mostrando as diferentes visualizações para o firestore CRUD

Vamos dividir este processo em X passos:

  • Etapa 1: crie e inicialize nosso aplicativo Ionic.
  • Etapa 2: adicione itens à lista.
  • Passo # 3: Mostre a lista de itens.
  • Passo # 4: Navegue até a página de detalhes de um item.
  • Etapa 5: excluir um item da lista.

Agora que sabemos o que vamos fazer, vamos pular para o modo de codificação.

Etapa 1: criar e inicializar seu aplicativo

O objetivo desta etapa é criar seu novo aplicativo iônico, instalar os pacotes necessários ( somente Firebase e AngularFire2 ) e inicializar nosso aplicativo do Firebase.

Com isso em mente, vamos criar nosso aplicativo primeiro, abrir seu terminal e navegar até a pasta que você usa para codificação ( ou em qualquer lugar que você quiser, para mim, essa é a pasta Desenvolvimento ) e criar seu aplicativo:

cd Development/
ionic start firestore-example blank
cd firestore-example 

Depois que criarmos o aplicativo, precisaremos instalar o Firebase. Para isso, abra o terminal novamente e ( enquanto estiver na raiz do projeto ), digite:

npm install angularfire2 firebase

Esse comando instalará as versões estáveis ​​mais recentes do AngularFire2 e do Firebase Web SDK.

Agora que instalamos tudo, vamos conectar o Ionic ao nosso aplicativo do Firebase.

A primeira coisa que precisamos é obter as credenciais do nosso aplicativo, fazer login no Firebase Console e navegar até o aplicativo do Firebase ( ou criar um novo caso você ainda não tenha o aplicativo ).

Na guia Visão geral do projeto, você verá a tela “Primeiros passos”, com opções para adicionar o Firebase a diferentes tipos de aplicativos, e selecione “Adicionar o Firebase ao seu aplicativo da web”.

De todo o código que aparece nessa janela pop-up, concentre-se nesse bit:

var config = {
  apiKey: "Your credentials here",
  authDomain: "Your credentials here",
  databaseURL: "Your credentials here",
  projectId: "Your credentials here",
  storageBucket: "Your credentials here",
  messagingSenderId: "Your credentials here",
};

Esse é o seu objeto de configuração do Firebase, ele tem todas as informações necessárias para acessar as diferentes APIs do Firebase, e precisaremos disso para conectar nosso aplicativo iônico ao nosso aplicativo do Firebase.

Vá para a sua src/apppasta e crie um arquivo chamado credentials.tsa idéia deste arquivo é manter todas as nossas credenciais em um só lugar, este arquivo não deve estar no controle de origem para adicioná-lo ao seu .gitignorearquivo.

Copie seu objeto de configuração para essa página. Vou mudar o nome para algo que faça mais sentido para mim:

export var firebasConfig = {
  apiKey: "AIzaSyBJT6tfre8uh3LGBm5CTiO5DUZ4",
  authDomain: "javebratt-playground.firebaseapp.com",
  databaseURL: "https://javebratt-playground.firebaseio.com",
  projectId: "javebratt-playground",
  storageBucket: "javebratt-playground.appspot.com",
  messagingSenderId: "3676553551"
};

Estamos exportando para que possamos importá-lo para outros arquivos onde precisarmos.

Agora é hora da parte final desta etapa, precisamos inicializar o Firebase, para isso, vamos entrar app.module.tse, primeiro, vamos importar os pacotes AngularFire2 que precisaremos e nosso objeto de credencial:

import { AngularFireModule } from 'angularfire2';
import { AngularFirestoreModule } from 'angularfire2/firestore';
import { firebaseConfig } from './credentials';

Como vamos usar apenas o banco de dados Firestore, importamos o módulo de base AF2 ( vou me referir a AngularFire2 como AF2 de agora em diante ) e o módulo Firestore. Se você também precisasse de autenticação ou armazenamento, você precisaria adicionar esses módulos aqui.

Dentro de sua @NgModule()aparência para sua importsmatriz e adicione o módulo AF2 e o módulo Firestore:

imports: [
  BrowserModule,
  IonicModule.forRoot(MyApp),
  AngularFireModule.initializeApp(firebaseConfig),
  AngularFirestoreModule,
],

Estamos chamando o .initializeApp(firebaseConfig)método e passando nosso objeto de credencial para que nosso aplicativo saiba como se conectar ao Firebase.

E é isso, pode não parecer muito ainda , mas nossos aplicativos Firebase e Ionic agora podem conversar entre si.

Etapa 2: adicione itens à lista.

É hora de começar a trabalhar com nossos dados, vamos construir um aplicativo CRUD, usaremos uma lista de músicas como um exemplo, mas os mesmos princípios se aplicam a qualquer fluxo de trabalho Mestre / Detalhe que você queira construir.

A primeira coisa que precisamos é entender como nossos dados são armazenados, o Firestore é um banco de dados NoSQL orientado a documentos, que é um pouco diferente do RTDB ( banco de dados em tempo real ).

Isso significa que temos dois tipos de dados em nosso banco de dados, documentos, que são objetos com os quais podemos trabalhar, e coleções que são os contêineres que agrupam esses objetos.

Por exemplo, se estivermos criando um banco de dados de músicas, nossa coleção seria chamada songs, ou songList, que conteria todos os objetos de música individuais e cada objeto teria suas propriedades, como o nome da música, o artista etc.

Em nosso exemplo, o objeto song terá cinco propriedades, um id, o álbum, o artista, uma descrição e o nome da música. No espírito de aproveitar os recursos de verificação de tipos do TypeScript, vamos criar uma interface que funcione como modelo para todas as nossas músicas.

Vá até a srcpasta e crie uma pasta chamada models, adicione um arquivo chamado song.interface.tse preencha-o com os seguintes dados:

export interface Song {
  id: string;
  albumName: string;
  artistName: string;
  songDescription: string;
  sonName: string;
}

Essa é a interface da música e garante que, sempre que estivermos trabalhando com um objeto de música, ele tenha todos os dados necessários.

Para começar a criar novas músicas e adicioná-las à nossa lista, precisamos ter uma página que contenha um formulário para inserir os dados da música, criar essa página com o Ionic CLI, abrir o terminal e digitar:

ionic generate page Create

Na verdade, enquanto estamos nisso, vamos dedicar alguns minutos para criar a página de detalhes, uma visualização detalhada de uma música específica e o provedor de Firestore, ele cuidará de todas as interações do banco de dados para que possamos gerenciar tudo desse arquivo.

ionic generate page Detail
ionic generate provider Firestore

Agora precisamos de uma maneira de ir da home page para o CreatePage, para que abrir home.htmle alterar seu cabeçalho para ficar assim:

<ion-header>
  <ion-navbar color="primary">
    <ion-title>
      Song List
    </ion-title>
    <ion-buttons end>
      <button ion-button icon-only (click)="goToCreatePage()">
        <ion-icon name="add"></ion-icon>
      </button>
    </ion-buttons>
  </ion-navbar>
</ion-header>

Estamos adicionando um botão ao cabeçalho que aciona a goToCreatePage()função, para que funcione, vamos abrir o home.tsarquivo e escrever essa função:

import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';

@Component({
  selector: 'page-home',
  templateUrl: 'home.html',
})
export class HomePage {
  constructor(public navCtrl: NavController) {}

  goToCreatePage(): void {
    this.navCtrl.push('CreatePage');
  }
}

A única coisa que esta função está fazendo é levá-lo para o CreatePage, agora que podemos chegar a essa página, é hora de construir sua funcionalidade. A funcionalidade consistirá em 3 coisas:

  • A exibição de HTML que mostra o formulário.
  • A classe TypeScript que coleta os dados do formulário e os envia ao provedor.
  • A função no provedor que cria a música e a adiciona à lista de músicas.

Vamos começar com o HTML, abrir o create.htmlarquivo e dentro das <ion-content></ion-content>tags criar o formulário:

<ion-content>
  <form [formGroup]="createSongForm" (submit)="createSong()" novalidate>
    <ion-item>
      <ion-label stacked>Song Name</ion-label>
      <ion-input formControlName="songName" type="text" 
        placeholder="What's this song called?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Artist Name</ion-label>
      <ion-input formControlName="artistName" type="text" 
        placeholder="Who sings this song?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Album Name</ion-label>
      <ion-input formControlName="albumName" type="text" 
        placeholder="What's the album's name?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Song Description</ion-label>
      <ion-textarea formControlName="songDescription" type="text" 
        placeholder="What's this song about?">
      </ion-textarea>
    </ion-item>


    <button ion-button block type="submit" [disabled]="!createSongForm.valid">
      Add Song
    </button>
  </form>

</ion-content>

Se você é novo em formas angulares, então aqui está o que está acontecendo:

  • [formGroup]="createSongForm" => Este é o nome do formulário que estamos criando.
  • (submit)="createSong()"=> Isso indica o formulário que, ao enviar, deve chamar a createSong()função.
  • formControlName => Este é o nome do campo.
  • [disabled]="!createSongForm.valid" => Isso define o botão a ser desativado até que o formulário seja válido.

Agora vamos para o create.tsarquivo, aqui coletamos os dados do nosso formulário e passamos para o nosso provedor. Primeiro, vamos importar tudo o que precisaremos:

import { Component } from '@angular/core';
import {
  IonicPage,
  NavController,
  Loading,
  LoadingController,
  AlertController,
  Alert,
} from 'ionic-angular';
import { FormGroup, FormBuilder, Validators } from '@angular/forms';
import { FirestoreProvider } from '../../providers/firestore/firestore';

Estamos importando:

  • Formulário métodos auxiliares de @angular/forms.
  • Carregando controlador para mostrar um widget de carregamento para nossos usuários enquanto o formulário processa os dados.
  • Alertar o controlador para exibir um alerta para o nosso usuário, se houver algum erro.
  • E o provedor Firestore para chamar a função que adicionará a música ao banco de dados.

Agora precisamos injetar todos esses provedores no construtor e inicializar nosso formulário:

public createSongForm: FormGroup; // This is the form we're creating.

constructor(
  public navCtrl: NavController,
  public loadingCtrl: LoadingController,
  public alertCtrl: AlertController,
  public firestoreProvider: FirestoreProvider,
  formBuilder: FormBuilder
) {
  this.createSongForm = formBuilder.group({
    albumName: ['', Validators.required],
    artistName: ['', Validators.required],
    songDescription: ['', Validators.required],
    songName: ['', Validators.required],
  });
}

E agora tudo que precisamos é a função que coleta os dados e os envia para o provedor, se você se lembrar da parte HTML, nós a chamamos createSong()

createSong(): void { }

A primeira coisa que queremos fazer dentro dessa função é acionar um componente de carregamento que permitirá ao usuário saber que os dados estão sendo processados ​​e, depois disso, extrairemos todos os dados de campo do formulário.

createSong(): void {
  const loading: Loading = this.loadingCtrl.create();
  loading.present();

  const albumName = this.createSongForm.value.albumName;
  const artistName = this.createSongForm.value.artistName;
  const songDescription = this.createSongForm.value.songDescription;
  const songName = this.createSongForm.value.songName;
}

E, por último, enviaremos os dados para o provedor, assim que a música for criada com sucesso, o usuário deverá navegar de volta para a página anterior, e se houver algo errado ao criá-lo, exibiremos um alerta com a mensagem de erro.

createSong(): void {
  const loading: Loading = this.loadingCtrl.create();
  loading.present();

  const albumName = this.createSongForm.value.albumName;
  const artistName = this.createSongForm.value.artistName;
  const songDescription = this.createSongForm.value.songDescription;
  const songName = this.createSongForm.value.songName;

  this.firestoreProvider
    .createSong(albumName, artistName, songDescription, songName)
    .then(
      () => {
        loading.dismiss().then(() => {
          this.navCtrl.pop();
        });
      },
      error => {
        loading.dismiss().then(() => {
          const alert: Alert = this.alertCtrl.create({
            message: error.message,
            buttons: [{ text: 'Ok', role: 'cancel' }],
          });
          alert.present();
        });
      }
    );
}

OBSERVAÇÃO: Como uma boa prática, manipule esses erros você mesmo, em vez de mostrar a mensagem de erro padrão para os usuários, certifique-se de fazer algo mais fácil de usar e usar suas mensagens personalizadas, somos técnicos, sabemos o que o erro significa, do tempo que nossos usuários não vão.

Nós quase terminamos essa parte, tudo que precisamos agora é criar a função dentro do provedor que recebe todos os dados do formulário que estamos enviando e usa para criar uma música em nosso banco de dados.

Abra providers/firestore/firestore.tse vamos fazer algumas coisas, precisamos:

  • Importar Firestore.
  • Importe nossa interface de música.
  • Injetar firestore no construtor.
  • E escreva a createSong()função que leva todos os parâmetros que enviamos do nosso formulário.
import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> { }
}

A função está tomando todos os parâmetros que estamos enviando. Agora vamos fazer algo que possa parecer incomum . Nós vamos usar a createId()função firestore para gerar um id para a nossa nova música.

import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> {
    const id = this.firestore.createId();
  }
}

O Firestore gera automaticamente IDs para nós quando enviamos itens para uma lista, mas eu gosto de criar primeiro o ID e depois armazená-lo dentro do item. Dessa forma, se eu puxar um item, posso obter sua ID e não tem que fazer quaisquer outras operações para obtê-lo.

Agora que criamos o id, vamos criar uma referência para essa música e definir todas as propriedades que temos, incluindo o id.

import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> {
    const id = this.firestore.createId();

    return this.firestore.doc(`songList/${id}`).set({
      id,
      albumName,
      artistName,
      songDescription,
      songName,
    });
  }
}

Essa última parte do código está criando uma referência ao documento identificado com esse ID em nossa songListcoleção e, depois de criar a referência, ele adiciona todas as informações que enviamos como parâmetros.

E é isso. Agora você pode adicionar músicas à nossa lista. E uma vez que cada música é criada, o usuário irá navegar de volta para a página inicial, onde vamos mostrar a lista de músicas armazenadas no banco de dados.

Passo # 3: Mostre a lista de itens.

Para mostrar a lista de músicas, seguiremos a mesma abordagem que usamos para nossa última funcionalidade, criaremos a exibição HTML, a classe TypeScript e a função dentro do provedor que se comunica com o Firebase.

Já que temos o provedor aberto a partir da funcionalidade anterior vamos começar por aí, queremos criar uma função chamada de getSongList()função que deva retornar uma coleção de músicas:

getSongList(): AngularFirestoreCollection<Song> {
  return this.firestore.collection(`songList`);
}

Note que para isso funcionar você precisa importar AngularFirestoreCollectiondo angularfire2/firestorepacote ( ou remover a verificação de tipo se você não se importa com isso ).

Agora, vamos para a página inicial e importamos tudo o que precisaremos:

import { Song } from '../../models/song.interface';
import { FirestoreProvider } from '../../providers/firestore/firestore';
import { Observable } from 'rxjs/Observable';

Queremos a Songinterface para uma verificação de tipo restrita, FirestoreProviderpara se comunicar com o banco de dados e Observabletambém para verificação de tipo, nosso provedor retornará um AngularFirestoreCollection que transformaremos em um observável para exibir em nossa visualização.

Então, dentro de nossa classe, queremos criar a songListpropriedade, vamos usá-la para exibir as músicas no HTML e injetar o provedor firestore no construtor.

public songList: Observable<Song[]>;
constructor(
  public navCtrl: NavController,
  public firestoreProvider: FirestoreProvider
) {}

E, por último, queremos esperar até que a página carregue e buscar a lista do nosso provedor:

ionViewDidLoad() {
  this.songList = this.firestoreProvider.getSongList().valueChanges();
}

.valueChanges()método pega o AngularFirestoreCollection e o transforma em um tipo Observable of Songs.

Agora podemos ir para home.htmldentro e dentro da <ion-content>nossa lista de músicas para exibir todas as músicas no banco de dados.

<ion-content>
  <ion-card *ngFor="let song of songList | async" 
    (click)="goToDetailPage(song)">
    <ion-card-header>
      {{ song.songName }}
    </ion-card-header>
    <ion-card-content>
      Artist Name: {{ song.artistName }}
    </ion-card-content>
  </ion-card>
</ion-content>

Estamos apenas mostrando o nome da música e o nome do artista, e estamos adicionando um evento de clique ao nosso cartão, uma vez que o usuário clica no cartão, ele deve acionar a goToDetailPage()função e passar todo o objeto da música como um parâmetro.

Nós não criamos essa função, então vamos criar um momento para criá-la em nossa homepage:

goToDetailPage(song: Song): void {
  this.navCtrl.push('DetailPage', { song: song });
}

A função navega o usuário até a página Detail e passa todo o objeto da música como um parâmetro de navegação. Na próxima seção, usaremos esse parâmetro de navegação para exibir os dados da música inteira na página de detalhes.

Por enquanto, pegue um biscoito ou algo assim, você já leu muito, e seus níveis de açúcar podem precisar de um impulso. Vejo vocês em alguns minutos na próxima seção🙂

Passo # 4: Navegue até a página de detalhes de um item.

Na etapa anterior, criamos uma função que nos leva à página de detalhes com as informações da música e, agora, vamos usar essas informações e exibi-las para o usuário ver.

Em vez de falar com o provedor para obter o registro da música, estamos passando a música inteira como um parâmetro de navegação, portanto, não precisamos importar nosso provedor do firestore agora.

A primeira coisa que faremos é detail.htmlcriar uma visualização básica que exiba todos os dados que temos para nossa música:

<ion-header>
  <ion-navbar color="primary">
    <ion-title>
      {{ song.songName }}
    </ion-title>
  </ion-navbar>
</ion-header>

<ion-content padding>
  <h3> Artist </h3>
  <p>
    The song {{ song.songName }} was released by {{ song.artistName }}.
  </p>

  <h3> Album </h3>
  <p>
    It was part of the {{ song.albumName }} album.
  </p>

  <h3> Description </h3>
  <p>
    {{ song.songDescription }}
  </p>
</ion-content>

Estamos mostrando o nome da música na barra de navegação e adicionamos o restante dos dados ao conteúdo da página.

Agora vamos pular detail.tspara que possamos fazer o songcontrário, isso irá cometer erros.

Tudo que você precisa fazer é criar uma propriedade songdo tipo Song, para isso precisamos importar a Songinterface.

Então, você deseja obter o parâmetro de navegação que enviamos para a página e atribuir seu valor à songpropriedade que você criou.

import { Component } from '@angular/core';
import { IonicPage, NavController, NavParams } from 'ionic-angular';
import { Song } from '../../models/song.interface';

@IonicPage()
@Component({
  selector: 'page-detail',
  templateUrl: 'detail.html',
})
export class DetailPage {
  public song: Song;
  constructor(public navCtrl: NavController, public navParams: NavParams) {
    this.song = this.navParams.get('song');
  }
}

Você deve fazer um teste agora mesmo, pois ionic serveseu aplicativo deve estar funcionando, e você deve ser capaz de criar novas músicas, mostrar a lista de músicas e entrar na página de detalhes de uma música.

Etapa 5: excluir um item da lista.

Na última parte do tutorial vamos adicionar um botão dentro da DetailPage, esse botão dará ao usuário a capacidade de remover músicas da lista.

Primeiro, abra detail.htmle crie o botão, nada muito chique, um botão regular que chame a função remove fará, configure-o imediatamente antes da tag de conteúdo iônico de fechamento.

<button ion-button block (click)="deleteSong(song.id, song.songName)">
    DELETE SONG
  </button>
</ion-content>

Agora vá para o detail.tse crie a deleteSong()função, ele deve levar 2 parâmetros, o ID da música e o nome da música:

deleteSong(songId: string, songName: string): void {}

A função deve acionar um alerta que solicita ao usuário uma confirmação e, se o usuário aceitar a confirmação, deverá chamar a função de exclusão do provedor e retornar à página anterior ( Nossa home page ou página de listagem ).

deleteSong(songId: string, songName: string): void {
    const alert: Alert = this.alertCtrl.create({
      message: `Are you sure you want to delete ${songName} from your list?`,
      buttons: [
        {
          text: 'Cancel',
          handler: () => {
            console.log('Clicked Cancel');
          },
        },
        {
          text: 'OK',
          handler: () => {
            this.firestoreProvider.deleteSong(songId).then(() => {
              this.navCtrl.pop();
            });
          },
        },
      ],
    });
    alert.present();
  }

NOTA: Certifique-se de importar Alert, AlertController e nosso FirestoreProvider para que isso funcione.

Agora, tudo o que precisamos fazer é ir ao nosso provedor e criar a função de exclusão:

deleteSong(songId: string): Promise<void> {
  return this.firestore.doc(`songList/${songId}`).delete();
}

A função usa o ID da música como um parâmetro e, em seguida, usa-a para criar uma referência a esse documento específico no banco de dados. Por último, chama o .delete()método nesse documento.

E é isso. Você deve ter uma funcionalidade Mestre / Detalhe totalmente funcional na qual possa listar objetos, criar novos objetos e excluir objetos do banco de dados.🙂

Próximos passos

Parabéns, esse foi longo, mas estou certo de que você agora entende mais sobre o Firestore e como usá-lo com o Firebase.

Se você quiser saber mais sobre o Firestore e começar a criar aplicativos Ionic mais completos, criei um Crash Course que aborda a teoria por trás do que vimos aqui e também inclui os disparadores do Cloud Functions para as regras de segurança do Firestore e do Firestore.

VOCÊ PODE RECEBER GRATUITAMENTE AQUI .

FONTE: https://javebratt.com/crud-ionic-firestore/

Conhecendo o MQTT

Por que o MQTT é um dos melhores protocolos de rede para a Internet das Coisas?

Para os dispositivos de Internet das Coisas (IoT), a conexão com a Internet é um requisito. A conexão com a Internet permite que os dispositivos trabalhem entre si e com serviços de backend. O protocolo de rede subjacente da Internet é o TCP/IP. Desenvolvido com base na pilha TCP/IP, o MQTT (Message Queue Telemetry Transport) tornou-se o padrão para comunicações de IoT.

O MQTT foi inventado e desenvolvido inicialmente pela IBM no final dos anos 90. Sua aplicação original era vincular sensores em pipelines de petróleo a satélites. Como seu nome sugere, ele é um protocolo de mensagem com suporte para a comunicação assíncrona entre as partes. Um protocolo de sistema de mensagens assíncrono desacopla o emissor e o receptor da mensagem tanto no espaço quanto no tempo e, portanto, é escalável em ambientes de rede que não são confiáveis. Apesar de seu nome, ele não tem nada a ver com filas de mensagens, na verdade, ele usa um modelo de publicação e assinatura. No final de 2014, ele se tornou oficialmente um padrão aberto OASIS, com suporte nas linguagens de programação populares, usando diversas implementações de software livre.

Por que o MQTT

O MQTT é um protocolo de rede leve e flexível que oferece o equilíbrio ideal para os desenvolvedores de IoT:

  • O protocolo leve permite a implementação em hardware de dispositivo altamente restringido e em redes de largura da banda limitada e de alta latência.
  • Sua flexibilidade possibilita o suporte a diversos cenários de aplicativo para dispositivos e serviços de IoT.

Para entender por que o MQTT é tão adequado para desenvolvedores de IoT, vamos analisar por que outros protocolos de rede populares falharam em IoT.

Por que não usar algum dos outros inúmeros protocolos de rede

A maioria dos desenvolvedores já se acostumou aos serviços da Web HTTP. Então, por que não conectar os dispositivos de IoT aos serviços da web? O dispositivo poderia enviar seus dados como uma solicitação de HTTP e receber atualizações do sistema como uma resposta de HTTP. Esse padrão de solicitação e resposta tem algumas limitações graves:

  • O HTTP é um protocolo síncrono. O cliente espera que o servidor responda. Os navegadores da web têm esse requisito, mas o custo é a baixa escalabilidade. No mundo da IoT, a comunicação síncrona tem sido um problema devido ao grande número de dispositivos e à rede, muitas vezes não confiável e de alta latência. Um protocolo de mensagem assíncrono é muito mais adequado para aplicativos de IoT. Os sensores podem enviar leituras e permitir que a rede descubra o caminho e a sincronização ideais para entregar aos dispositivos e serviços de destino.
  • HTTP é unidirecional. O cliente precisa iniciar a conexão. Em um aplicativo de IoT, os dispositivos e sensores geralmente são clientes, o que significa que eles não podem receber comandos da rede passivamente.
  • HTTP é um protocolo de um para um. O cliente faz uma solicitação e o servidor responde. É difícil e caro transmitir uma mensagem a todos os dispositivos na rede, o que é um caso de uso comum em aplicativos de IoT.
  • HTTP é um protocolo pesado com muitos cabeçalhos e regras. Ele não é adequado para redes restringidas.

Pelos motivos citados acima, a maioria dos sistemas escaláveis de alto desempenho usam um barramento do sistema de mensagens assíncrono, em vez de serviços da web, para trocas de dados internas. Na verdade, o protocolo de sistema de mensagens mais popular que é usado em sistemas de middleware corporativos é chamado AMQP (Advanced Message Queuing Protocol). No entanto, no ambiente de alto desempenho, a capacidade de computação e a latência da rede geralmente não são uma preocupação. O AMQP foi criado para assegurar a confiabilidade e a interoperabilidade em aplicativos corporativos. Ele possui um rico conjunto de recursos, mas não é adequado para aplicativos de IoT com restrição de recursos.

Além do AMQP, existem outros protocolos populares de sistema de mensagens. Por exemplo, o XMPP (Extensible Messaging and Presence Protocol) é um protocolo de mensagem instantânea (IM) ponto a ponto. Ele é pesado em recursos com suporte para casos de uso de IM, como presença e anexos de mídia. Em comparação com o MQTT, ele requer muito mais recursos no dispositivo e na rede.

Então, como o MQTT consegue ser tão leve e flexível? Um importante recurso do protocolo MQTT é o modelo de publicação e assinatura. Como em todos os protocolos de sistema de mensagens, ele desacopla o publicador e o consumidor de dados.

O modelo de publicação e assinatura

O protocolo MQTT define dois tipos de entidades na rede: um message broker e inúmeros clientes. O broker é um servidor que recebe todas as mensagens dos clientes e, em seguida, roteia essas mensagens para os clientes de destino relevantes. Um cliente é qualquer coisa que possa interagir com o broker e receber mensagens. Um cliente pode ser um sensor de IoT em campo ou um aplicativo em um data center que processa dados de IoT.

  1. O cliente conecta-se ao broker. Ele pode assinar qualquer “tópico” de mensagem no broker. Essa conexão pode ser uma conexão TCP/IP simples ou uma conexão TLS criptografada para mensagens sensíveis.
  2. O cliente publica as mensagens em um tópico, enviando a mensagem e o tópico ao broker.
  3. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Como as mensagens do MQTT são organizadas por tópicos, o desenvolvedor de aplicativos tem a flexibilidade de especificar que determinados clientes somente podem interagir com determinadas mensagens. Por exemplo, os sensores publicarão suas leituras no tópico “sensor_data” e assinarão o tópico “config_change”. Os aplicativos de processamento de dados que salvam os dados do sensor em um banco de dados de backend assinarão o tópico “sensor_data”. Um aplicativo de console administrativo poderia receber comandos do administrador do sistema para ajustar as configurações dos sensores, como a sensibilidade e a frequência de amostragem, e publicar essas mudanças no tópico “config_change”. (Consulte Figura 1.)

Figura 1. O modelo de publicação e assinatura do MQTT para sensores de IoT

Ao mesmo tempo, o MQTT é leve. Ele tem um cabeçalho simples para especificar o tipo de mensagem, um tópico baseado em texto e, em seguida, uma carga útil binária arbitrária. O aplicativo pode usar qualquer formato de dados para a carga útil como JSON, XML, binário criptografado ou Base64, desde que os clientes de destino possam analisar a carga útil.

Introdução ao desenvolvimento com MQTT

A ferramenta mais fácil para começar o desenvolvimento com MQTT é o módulo Python mosquitto, que faz parte do projeto Eclipse Paho e fornece SDKs e bibliotecas do MQTT em várias linguagens de programação. Ele contém um broker do MQTT que pode ser executado no computador local e ferramentas de linha de comandos que podem interagir com o broker usando mensagens. É possível fazer download e instalar o módulo mosquitto no website do mosquitto.

O comando mosquitto executa o broker do MQTT no computador local. Opcionalmente, é possível usar a opção -d para executá-lo em segundo plano.

$ mosquitto -d

Em seguida, em outra janela do terminal, é possível usar o comando mosquitto_sub para conectar-se ao broker local e assinar um tópico. Após a execução do comando, ele vai esperar e imprimir todas as mensagens que receber da assinatura, à medida que elas forem chegando.

$ mosquitto_sub -t "dw/demo"

Em uma outra janela do terminal, é possível usar o comando mosquitto_pub para conectar-se ao broker local e, em seguida, publicar uma mensagem em um tópico.

$ mosquitto_pub -t "dw/demo" -m "hello world!"

Agora, o terminal que executa o mosquitto_sub deverá exibir “hello world!” na tela. Você acabou de enviar e receber uma mensagem usando um broker do MQTT!

É claro que em um sistema de produção, não é possível usar um computador local como o broker. Nesse caso, é possível usar o Serviço da plataforma Internet das Coisas do IBM Bluemix, que é um serviço sob demanda e confiável que funciona como um broker do MQTT. (Leia mais sobre como esse serviço do Bluemix se integra e usa o MQTT como seu protocolo para comunicar-se com dispositivos e aplicativos na documentação do serviço.)

O nó Serviço da plataforma Internet das Coisas do IBM Bluemix funciona da seguinte forma.

  • No console do Bluemix, é possível criar uma instância do serviço da plataforma Internet das Coisas sob demanda.
  • Em seguida, é possível incluir dispositivos que possam conectar a instância de serviço usando o MQTT. Cada dispositivo terá um ID e um nome. Somente os dispositivos listados podem acessar o serviço, e o painel da plataforma Watson IoT relatará informações sobre tráfego e uso desses serviços, nos respectivos dispositivos.
  • Para cada cliente do dispositivo, o Bluemix designará um nome do host, um nome de usuário e uma senha para a conexão com a instância de serviço (o broker do MQTT). (No Bluemix, o nome de usuário sempre é use-token-auth e a senha é o token que é mostrado na Figura 2 para cada dispositivo conectado.)
Figura 2. Criando uma instância de serviço da plataforma Internet das Coisas no IBM Bluemix

Ao usar um broker remoto do MQTT, será necessário passar pela aprovação das credenciais de autenticação e de nome do host do broker para os comandos mosquitto_sub e mosquitto_pub. Por exemplo, o comando a seguir assina o tópico de demonstração no nosso serviço da plataforma Internet das Coisas com o nome de usuário e senha fornecidos pelo Bluemix:

$ mosquitto_sub -t "demo" -h host.iotp.mqtt.bluemix.com -u username -P password

Para conhecer mais opções de como usar as ferramentas do mosquitto e também de como usar a API do mosquitto para criar seus próprios aplicativos clientes do MQTT, consulte a documentação no website do mosquitto.

Agora que você já tem as ferramentas necessárias, vamos nos aprofundar no protocolo MQTT.

Entendendo o protocolo MQTT

O MQTT é um protocolo de ligação que especifica como os bytes de dados são organizados e transmitidos pela rede TCP/IP. Mas por motivos práticos, os desenvolvedores não precisam entender o protocolo de ligação. Basta saber que cada mensagem tem uma carga útil de comando e dados. O comando define o tipo de mensagem (por exemplo, uma mensagem CONNECT ou uma mensagem SUBSCRIBE). Todas as bibliotecas e ferramentas do MQTT oferecem maneiras simples de manipular essas mensagens diretamente e podem preencher automaticamente alguns campos necessários, como os IDs da mensagem e do cliente.

Primeiro, o cliente conecta-se ao broker enviando uma mensagem CONNECT. A mensagem CONNECT pede para estabelecer uma conexão do cliente com o broker. A mensagem CONNECT tem os parâmetros de conteúdo a seguir.

Tablela 1. Parâmetros da mensagem CONNECT
Parâmetro Descrição
cleanSession Esta sinalização especifica se a conexão é persistente ou não. Uma sessão persistente armazena todas as assinaturas e as mensagens possivelmente perdidas (dependendo do QoS) no broker. (Consulte Tablela 3 para obter uma descrição do QoS).
username As credenciais de autenticação e autorização do broker.
password As credenciais de autenticação e autorização do broker.
lastWillTopic Quando a conexão for encerrada inesperadamente, o broker publicará automaticamente uma mensagem de “último desejo” em um tópico.
lastWillQos O QoS da mensagem de “último desejo”. (Consulte Tablela 3 para obter uma descrição do QoS).
lastWillMessage A própria mensagem de “último desejo”.
keepAlive Este é o intervalo de tempo em que o cliente precisa efetuar ping no broker para manter a conexão ativa.

O cliente receberá uma mensagem CONNACK do broker. A mensagem CONNACK tem os parâmetros de conteúdo a seguir.

Tablela 2. Parâmetros da mensagem CONNACK
Parâmetro Descrição
sessionPresent Indica se a conexão já tem uma sessão persistente. Ou seja, a conexão já tem tópicos assinados e receberá a entrega de mensagens ausentes.
returnCode 0 indica sucesso. Outros valores identificam a causa da falha.

Depois que uma conexão for estabelecida, o cliente poderá enviar uma ou mais mensagens SUBSCRIBE ao broker para indicar que ele receberá mensagens do broker de determinados tópicos. A mensagem pode ter uma ou várias repetições dos parâmetros a seguir.

Tablela 3. Parâmetros da mensagem SUBSCRIBE
Parâmetro Descrição
qos A sinalização qos (qualidade de serviço ou QoS) indica com que consistência as mensagens neste tópico precisam ser entregues aos clientes.

  • Valor 0: não confiável, a mensagem é entregue no máximo uma única vez, se o cliente estiver indisponível no momento, ele perderá a mensagem.
  • Valor 1: a mensagem deve ser entregue pelo menos uma vez.
  • Valor 2: a mensagem deve ser entregue exatamente uma vez.
tópico Um tópico para assinar. Um tópico pode ter vários níveis separados pelo caractere barra. Por exemplo, “dw/demo” e “ibm/bluemix/mqtt” são tópicos válidos.

Depois que o cliente tiver assinado um tópico com sucesso, o broker retornará uma mensagem SUBACK com um ou mais parâmetros returnCode.

Tablela 4. Parâmetros da mensagem SUBACK
Parâmetro Descrição
returnCode Existe um código de retorno para cada um dos tópicos no comando SUBSCRIBE. Os valores de retorno são os seguintes.

  • Valores 0 a 2: sucesso como nível de QoS correspondente. (Consulte Tablela 3 para saber mais sobre QoS.)
  • Valor 128: falha.

Correspondendo à mensagem SUBSCRIBE, o cliente também poderá UNSUBSCRIBE (cancelar a assinatura) de um tópico ou de vários tópicos.

Tablela 5. Parâmetros da mensagem UNSUBSCRIBE
Parâmetro Descrição
tópico Este parâmetro pode se repetir para vários tópicos.

O cliente pode enviar mensagens PUBLISH ao broker. A mensagem contém um tópico e uma carga útil de dados. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Tablela 6. Parâmetros da mensagem PUBLISH
Parâmetro Descrição
topicName O tópico no qual a mensagem é publicada.
qos O nível de qualidade de serviço da entrega da mensagem. (Consulte Tablela 3 para obter uma descrição do QoS).
retainFlag Esta sinalização indica se o broker reterá a mensagem como a última mensagem conhecida deste tópica.
carga útil Os dados reais na mensagem. Pode ser uma sequência de texto ou um blob binário de dados.

Dicas e soluções alternativas

O poder do MQTT é a simplicidade. Não há restrições quanto ao tipo de tópico ou de carga útil de mensagem que se pode usar. Isso permite alguns casos de uso interessantes. Por exemplo, considere estas questões:

Como executar mensagens de um para um com o MQTT? Ambas as partes podem concordar em usar um tópico que seja exclusivo para elas. Por exemplo, o nome do tópico pode conter os IDs dos dois clientes para garantir sua exclusividade.

Como um cliente transmite seu status de presença? O sistema pode concordar com uma convenção de nomenclatura para tópicos de “presença”. Por exemplo, o tópico “presence/client-id” pode conter as informações de presença do cliente. O cliente define a mensagem como true quando se conecta e false quando se desconecta. O cliente também pode configurar uma mensagem de last will como false para ser definida quando a conexão for encerrada. A mensagem pode ser retida pelo broker para que novos clientes possam ler o tópico e descobrir o status de presença.

Como proteger as comunicações? A conexão do cliente com o broker pode ser uma conexão TLS criptografada para proteger os dados em trânsito. Além disso, como o protocolo MQTT não impõe restrições quanto ao formato de dados da carga útil, o sistema pode concordar com um método de criptografia e um mecanismo de atualização de chave. Depois disso, todo o conteúdo na carga útil pode ser dados binários criptografados das mensagens JSON ou XML reais.

Conclusão

Neste artigo eu ofereci uma introdução técnica ao protocolo MQTT. Você aprendeu o que é o MQTT, por que ele é adequado para aplicativos de IoT e como começar a desenvolver aplicativos que usam o MQTT.

Em um de meus próximos artigos, vou mostrar como desenvolver uma solução de sensor de IoT completa com serviços de MQTT de backend e usando uma placa NodeMCU.

Recursos

Recursos para download

Temas relacionados

Fonte:  https://www.ibm.com/developerworks/br/library/iot-mqtt-why-good-for-iot/index.html

Mosquitto Eclipse – Um Broker MQTT de Software Livre

O Eclipse Mosquitto é um intermediário de mensagens de código-fonte aberto (licenciado por EPL / EDL) que implementa as versões 3.1 e 3.1.1 do protocolo MQTT. O Mosquitto é leve e adequado para uso em todos os dispositivos, desde computadores de mesa única de baixa potência até servidores completos.

O protocolo MQTT fornece um método leve de executar mensagens usando um modelo de publicação / assinatura. Isso o torna adequado para mensagens da Internet das Coisas, como sensores de baixa potência ou dispositivos móveis, como telefones, computadores embutidos ou microcontroladores.

O projeto Mosquitto também fornece uma biblioteca C para implementar clientes MQTT, e os populares clientes MQTT da linha de comando mosquitto_pub e mosquitto_sub.

O Mosquitto faz parte da Eclipse Foundation e é um projeto do iot.eclipse.org

Baixar

O Mosquitto é altamente portátil e está disponível para uma ampla gama de plataformas. Vá para a página de download dedicada para encontrar a origem ou os binários para sua plataforma.

Leia o log de alterações para saber mais sobre os lançamentos recentes.

Teste

Você pode ter sua própria instância do Mosquitto em execução em minutos, mas para tornar o teste ainda mais fácil, o Projeto Mosquitto executa um servidor de teste em test.mosquitto.org onde você pode testar seus clientes de várias maneiras: MQTT simples, MQTT sobre TLS , MQTT sobre TLS (com certificado de cliente , MQTT sobre WebSockets e MQTT sobre WebSockets com TLS.

plataformas.

Comunidade

Segurança

Use a página de segurança para descobrir como denunciar vulnerabilidades ou respostas a problemas de segurança anteriores.

Fonte

Downloads mais antigos estão disponíveis em http://mosquitto.org/files/

Instalação Binária

janelas

Veja o arquivo readme-windows.txt depois de instalar os detalhes e dependências específicos do Windows.

Mac

Mosquitto pode ser instalado a partir do projeto homebrew. Veja brew.sh e depois usebrew install mosquitto

Arch Linux

  • Mosquitto pode ser encontrado no repositório da comunidade.

CentOS

Baixe o arquivo de configuração do repositório para sua versão do CentOS a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. CentOS 7CentOS 6

Debian

  • O Mosquitto agora está no Debian. Haverá um pequeno atraso entre uma nova versão e ela aparecerá no Debian como parte dos procedimentos normais da Debian.
  • Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository>

Fedora

O Mosquitto está agora disponível diretamente no Fedora. Use yum install mosquittoou pesquise “mosquito” para encontrar os pacotes relacionados.

FreeBSD

Mosquitto está disponível para o FreeBSD: http://www.freshports.org/net/mosquitto/

Gentoo

Usar emerge mosquitto

openSUSE

Faça o download do arquivo de configuração do repositório para a sua versão do openSUSE abaixo e copie-o para /etc/zypp/repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

As embalagens disponíveis são: mosquitto, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto.

OpenWrt

Se você estiver usando um instantâneo de tronco, use opkg update; opkg install mosquitto

Karl Palsson mantém um conjunto de feeds que podem ser mais atualizados do que a versão atual do OpenWrt:

Raspberry Pi

Mosquitto está disponível através do repositório principal.

Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository/

Redhat Enterprise Linux

Faça o download do arquivo de configuração do repositório para sua versão do RHEL a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquitto atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. RHEL 7RHEL 6

SUSE Linux Enterprise Server

Adicione o repositório apropriado à sua configuração de pacote na lista abaixo e instale o mosquitto a partir de suas ferramentas normais de gerenciamento de pacotes.

Ubuntu

O Mosquitto está disponível nos repositórios do Ubuntu para que você possa instalar como em qualquer outro pacote. Se você estiver em uma versão anterior do Ubuntu ou quiser uma versão mais recente do mosquitto, adicione o PPA mosquitto-dev à sua lista de repositórios – veja o link para detalhes. O mosquito pode então ser instalado a partir do gerenciador de pacotes.

  • sudo apt-add-repository ppa:mosquitto-dev/mosquitto-ppa
  • sudo apt-get update

Se o comando apt-add-repositorynão for reconhecido, ele poderá ser instalado com:

  • sudo apt-get install python-software-properties

Iphone

Você pode usar o libmosquitto (incluído no download da fonte) no iPhone para criar aplicativos MQTT. Ele compila como objective-c, ou você pode usar o projeto marquette que é um wrapper object-c e aplicativo de exemplo.

Fonte: https://mosquitto.org/download/

 .

Mosquitto e paho-mqtt-python

Mosquitto e paho-mqtt-python

Melhore a segurança do mosquito no Ubuntu 16.04 LTS

Instalar mosquito
> sudo apt-adicionar-repositório ppa: mosquitto-dev / mosquitto-ppa
> sudo apt-get atualizar
> sudo apt-get instalar mosquitto mosquitto-clients

Instalar o paho-mqtt-python
> pip install paho-mqtt

Configurar mosquito
> sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistência true 
persistence_location / var / lib / mosquitto / 
allow_anonymous falso 
arquivo log_dest /var/log/mosquitto/mosquitto.log 
include_dir /etc/mosquitto/conf.d

Adicione a confoguração do mosquito
> sudo vi /etc/mosquitto/conf.d/default.conf

password_file / etc / mosquitto / passwd
ouvinte 1883 localhost
listener 8883 
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem 
cafile /etc/letsencrypt/live/[hostname]/chain.pem 
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem

Adicionar nome de usuário e senha do
mosquitto> mosquitto_passwd -c / etc / mosquitto / passwd [nome de usuário]
Senha: [senha]
Redigite a senha: [senha]

Teste com o assinante do mosquitto
> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -q [qos] -c -i [clientid] -u [username] -P [senha]

Teste com o editor de mosquitos
> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [senha]

assinante paho-mqtt

 

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

 

Configurar mosquito

>sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistence true
persistence_location /var/lib/mosquitto/
allow_anonymous false
log_dest file /var/log/mosquitto/mosquitto.log
include_dir /etc/mosquitto/conf.d

Adicione a configuração do mosquito

password_file /etc/mosquitto/passwd
listener 1883 localhost
listener 8883
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem
cafile /etc/letsencrypt/live/[hostname]/chain.pem
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem
include_dir /etc/mosquitto/conf.d

Adicionar nome de usuário e senha do

> mosquitto_passwd -c /etc/mosquitto/passwd [username]
Password: [password]
Reenter password: [password]

 

Teste com o assinante do mosquitto

> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -q [qos] -c -i [clientid] -u [username] -P [password]

 

Teste com o editor de mosquitos

> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [password]

Assinante paho-mqtt

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

Editor paho-mqtt

import ssl
import sys

import paho.mqtt.client
import paho.mqtt.publish

def on_connect(client, userdata, flags, rc):
	print('connected')

def main():
	paho.mqtt.publish.single(
		topic='[topic]',
		payload='[message]',
		qos=2,
		hostname='[hostname]',
		port=8883,
		client_id='[clientid]',
		auth={
			'username': '[username]',
			'password': '[password]'
		},
		tls={
			'ca_certs': '/etc/ssl/certs/DST_Root_CA_X3.pem',
			'tls_version': ssl.PROTOCOL_TLSv1_2
		}
	)

if __name__ == '__main__':
	main()
	sys.exit(0)

 

erinus diz:

Se o seu assinante quiser receber todas as mensagens não lidas em um tópico após o início, você deverá concluir estas etapas:

Use o mesmo ID de cliente quando você inicia o assinante.
Use clean_session = False quando você inicia o assinante.
Use qos> 0 quando você assina um tópico.
Use qos> 0 quando você publicar uma mensagem.

Para tornar suas comunicações mais seguras, você deve concluir estas etapas:

Usar TLS 1.2
Set allow_anonymous = False
Habilitar autenticação com nome de usuário e senha

Se você quer mais métodos de autenticação, tente este plugin mosquitto:

https://github.com/jpmens/mosquitto-auth-plug

 

Fonte:  https://medium.com/@erinus/mosquitto-paho-mqtt-python-29cadb6f8f5c

 

 

 

 

Princípios Básicos da API SOAP do PayPal

A API do PayPal SOAP é baseada em padrões abertos conhecidos coletivamente como serviços da Web, que incluem o SOAP (Simple Object Access Protocol), o WSDL (Web Services Definition Language) e o XSD (XML Schema Definition language). Uma ampla variedade de ferramentas de desenvolvimento em diversas plataformas oferece suporte a serviços da Web.

Como muitos serviços da Web, o PayPal SOAP é uma combinação de esquemas do lado do cliente e do lado do servidor, servidores de hardware e software e serviços principais.

Diagrama de alto nível do PayPal SOAP

Em um modelo de processamento orientado a objetos, a interface para solicitações / respostas SOAP é um objeto na linguagem de programação nativa do seu aplicativo. Seu cliente SOAP de terceiros gera interfaces de objeto de negócios e stubs de rede dos arquivos WSDL e XSD fornecidos pelo PayPal que especificam a estrutura de mensagens do PayPal SOAP, seu conteúdo e as ligações de serviço da API do PayPal. Um aplicativo de negócios trabalha com dados na forma de propriedades do objeto para enviar e receber dados chamando métodos de objeto. O cliente SOAP manipula os detalhes da criação da solicitação SOAP, enviando-a ao serviço do PayPal e convertendo a resposta de volta para um objeto.

Definições de esquema do PayPal WSDL / XSD

O esquema de Serviços da Web do PayPal e seus componentes básicos e base do eBay Business Language (eBL) são necessários para o desenvolvimento de aplicativos com a API de serviços da Web do PayPal. A seguir estão os locais dos arquivos WSDL e XSD.

Localização dos arquivos PayPal WSDL e XSD
Desenvolvimento e teste com a sandbox do PayPal
Esquema do PayPal https://www.sandbox.paypal.com/wsdl/PayPalSvc.wsdl
Componentes básicos e componentes do eBL https://www.sandbox.paypal.com/wsdl/eBLBaseComponents.xsd 
https://www.sandbox.paypal.com/wsdl/CoreComponentTypes.xsd
Produção com a API do PayPal ao vivo
Esquema do PayPal https://www.paypal.com/wsdl/PayPalSvc.wsdl
Componentes básicos e componentes do eBL https://www.paypal.com/wsdl/eBLBaseComponents.xsd 
https://www.paypal.com/wsdl/CoreComponentTypes.xsd

Definições da API do SOAP do PayPal

A API do PayPal para SOAP inclui definições de API individuais para funções comerciais específicas. Como base, a API depende dos componentes básicos e básicos da eBay Business Language (eBL). As principais estruturas do eBL AbstractRequestTypeAbstractResponseTypesão a base da solicitação e resposta do SOAP de cada API do PayPal. AbstractResponseTypetambém é a estrutura para mensagens de erro comuns em todas as APIs do PayPal.

O PayPal tomou algumas decisões de design de esquema que podem afetar como os negócios projetam seus próprios aplicativos.

  • Enumerações – Enumerações são definidas diretamente no esquema da API do PayPal.
  • Informações de solução de problemas – A API do PayPal retorna informações sobre elementos que acionam erros.
  • Compatibilidade retroativa – A API do PayPal é versionada para que os aplicativos de negócios sejam compatíveis com versões anteriores quando novos elementos são introduzidos no esquema do lado do servidor.

Nota: O eBL define muitas estruturas específicas para leilões de processamento. O esquema SOAP do PayPal inclui essas definições para manter a compatibilidade com o SOAP do eBay. O material se concentra apenas nas definições de SOAP pertinentes ao uso da API do PayPal SOAP.

Segurança

O serviço da API SOAP do PayPal é protegido para garantir que apenas membros autorizados do PayPal o usem. Existem quatro níveis de segurança:

  1. Uma API Usernamee uma API obrigatórias Password.
  2. Um terceiro mecanismo de autenticação obrigatório, que é um dos seguintes:
    • Assinatura de solicitação do lado do cliente usando um certificado de API emitido pelo PayPal
    • Solicitar autenticação usando uma assinatura de API incluída na solicitação
  3. Se você estiver chamando a API em nome de um comerciante de terceiros, deverá especificar o endereço de e-mail registrado no PayPal do comerciante de terceiros ou o ID da conta do comerciante (às vezes chamado de ID do pagador) no Subjectcampo.

    Nota: Terceiros podem obter seu ID de comerciante entrando no paypal.com , clicando no ícone do perfil ( Menu Perfil) no canto superior direito da página e selecionando Perfil e configurações no menu Perfil de negócios . (Se o ícone do perfil na parte superior da página não estiver visível, clique em Perfil , que aparece no menu superior quando a guia Minha conta estiver selecionada.) Clique em Informações da minha empresa à esquerda e o ID da conta do comerciante é exibido no lista de itens de perfil à direita.

    Normalmente, um comerciante concede permissões de terceiros a um carrinho de compras, portanto, o carrinho de compras pode chamar a API em nome do comerciante. O comerciante deve ter concedido anteriormente permissão para executar a operação da API.

  4. Transporte de dados TLS (Transport Layer Security). Consulte as diretrizes de segurança das informações do desenvolvedor do PayPal para obter mais informações sobre o TLS.

Uma falha na segurança autenticada em qualquer um desses níveis nega acesso ao serviço da API do PayPal SOAP.

RequesterCredentials SOAP: nome de usuário, senha, assinatura e assunto

Para a segurança de seus negócios, o PayPal deve verificar se os comerciantes ou desenvolvedores de terceiros têm permissão para iniciar uma transação antes de fazer uma. O PayPal autentica cada solicitação. Se a solicitação não puder ser autenticada, uma falha de segurança SOAP será retornada.

No cabeçalho da solicitação SOAP, seu cliente SOAP deve definir os elementos UsernamePasswordpara passar uma combinação de nome de usuário / senha da API. Além disso, você pode definir o Signaturepara especificar sua string de assinatura de API. Se você estiver chamando a API em nome de um comerciante de terceiros, deverá definir o Subjectelemento para especificar o endereço de e-mail de terceiros ou o ID da conta do comerciante (às vezes chamado de ID do pagador).

Nota: Terceiros podem obter seu ID de comerciante entrando no paypal.com , clicando no ícone do perfil ( Menu Perfil) no canto superior direito da página e selecionando Perfil e configurações no menu Perfil de negócios . (Se o ícone do perfil na parte superior da página não estiver visível, clique em Perfil , que aparece no menu superior quando a guia Minha conta estiver selecionada.) Clique em Informações da minha empresa à esquerda e o ID da conta do comerciante é exibido no lista de itens de perfil à direita.

Normalmente, um comerciante concede permissões de terceiros a um carrinho de compras, portanto, o carrinho de compras pode chamar a API em nome do comerciante. O comerciante deve ter concedido anteriormente permissão para executar a operação da API.

O exemplo a seguir mostra parte dos RequesterCredentialselementos.

A maioria desses elementos é necessária para todas as solicitações SOAP.

<SOAP-ENV:Header>
  <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI" xsi:type="ebl:CustomSecurityHeaderType">
  <Credentials xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:UserIdPasswordType">
    <Username>API-Username</Username>
    <Password>API-Password</Password>
    <Signature>API-Signature</Signature>
    <Subject>Authorizing-Merchant-Email -or- Authorizing-Merchant-Account-ID</Subject>
  </Credentials>
  </RequesterCredentials>
</SOAP-ENV:Header>
Elementos de autenticação RequesterCredentials no cabeçalho SOAP
Elemento Valor Descrição
Username API-Username Seu nome de usuário da API, que é gerado automaticamente pelo PayPal quando vocêsolicita credenciais de API de certificado ou assinatura para usar a API do PayPal SOAP. Você pode ver esse valor em https://www.paypal.com/ em seu perfil em Acesso à API> Credenciais da API.
Password API-Password Sua senha da API, que você especifica quandosolicita credenciais de API de certificado ou assinatura para usar a API do PayPal SOAP.
Signature API-Signature Sua assinatura de API , se você usar uma em vez de um certificado de API.
Subject Authorizing-Merchant-Email

ou

Authorizing-Merchant-Account-ID

O endereço de e-mail ou ID da conta do comerciante (às vezes chamado de ID do pagador) de um terceiro para quem você está enviando solicitações para a API do PayPal para SOAP. Seu nome de usuário da API deve terrecebido permissão desse terceiro para fazer uma solicitação da API do PayPal em seu nome.

Pontos de extremidade do serviço SOAP

O terminal em serviço que processa suas solicitações SOAP depende do tipo de credenciais da API.

Pontos de extremidade do serviço SOAP
Tipo de credenciais da API Ponto de extremidade de produção ao vivo Ponto de extremidade de teste (sandbox)
Certificado de API https://api.paypal.com/2.0/ https://api.sandbox.paypal.com/2.0/
Assinatura API https://api-3t.paypal.com/2.0/ https://api-3t.sandbox.paypal.com/2.0/

Envelope de pedido SOAP

O diagrama a seguir ilustra o conteúdo de um envelope de solicitação do PayPal SOAP.

Todas as APIs do PayPal são baseadas em duas estruturas principais: AbstractRequestTypeAbstractResponseType.

Diagrama do envelope de solicitação SOAP

Solicitar estrutura

A descrição anotada a seguir da estrutura de solicitação SOAP mostra os elementos requeridos pela API do PayPal SOAP.

Estrutura geral da solicitação SOAP da API do PayPal

1.  <?xml version="1.0" encoding="UTF-8"?>
2.  <SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
3.    <SOAP-ENV:Header>
4.      <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI">
5.        <Credentials xmlns="urn:ebay:apis:eBLBaseComponents">
6.          <Username>API-Username</Username>
7.          <Password>API-Password</Password>
8.          <Signature/>
9.          <Subject/>
10.       </Credentials>
11.     </RequesterCredentials>
12.   </SOAP-ENV:Header>
13.   <SOAP-ENV:Body>
14.     <Specific-API-Name-Req xmlns="urn:ebay:api:PayPalAPI">
15.       <Specific-API-Name-Request>
16.         <Version xmlns="urn:ebay:apis:eBLBaseComponents">API-Version</Version>
17.         <Required-Or-Optional-Fields xs:type="Type">Data</Required-Or-Optional-Fields>
18.       </Specific-API-Name-Request>
19.     </Specific-API-Name-Req>
20.   </SOAP-ENV:Body>
21. </SOAP-ENV:Envelope>
Anotação de solicitação SOAP genérica
Linhas Comente
6, 7 Os campos UsernamePasswordsão parte do RequesterCredentialsmecanismo de autenticação de segurança da API SOAP do PayPal que você deve construir para cada cabeçalho de solicitação SOAP. Veja RequesterCredentials para mais informações.
8 Signatureelemento deve incluir sua assinatura de API se esse for o tipo de credencial de API que você está usando.
9 Subjectelemento deve ser incluído ao usar permissões de terceiros (realizando transações em nome de outro comerciante que tenha autorizado você a fazer isso). Passe o ID da conta do comerciante de terceiros autorizador (às vezes chamado de ID do pagador) ou endereço de e-mail.
13 a 20 A solicitação SOAP para cada API do PayPal segue esse padrão de nomenclatura de elemento. O nome específico da API é anexado com Reqe, nesse elemento, o nomeSpecific-API-Name-Reqé aninhado. Cada Specific-API-Name-Requestum tem um correspondente Specific-API-Name-RequestType.
16 O número da versão da API do PayPal SOAP é necessário em cada solicitação SOAP. Este número de versão é o valor de ns:versionem https://www.paypal.com/wsdl/PayPalSvc.wsdl .
17 Para detalhes sobre elementos obrigatórios e opcionais e valores para solicitações específicas, consulte as referências da API .

Estilo da Mensagem SOAP: doc-literal

PayPal usa doc-literalmensagens SOAP, não rpc-encoding. Com doc-literal, uma única chamada de interface de serviço passa um documento XML na solicitação para o servidor da API do PayPal, que responde com uma instância do documento XML.

Estrutura de Resposta

A seguir, uma descrição anotada da estrutura de uma resposta SOAP bem-sucedida da API do PayPal, em que Ack=Success:

1.  <?xml version="1.0"?>
2.  <SOAP-ENV:Envelope
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:cc="urn:ebay:apis:CoreComponentTypes"
    xmlns:wsu="http://schemas.xmlsoap.org/ws/2002/07/utility"
    xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion"
    xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
    xmlns:wsse="http://schemas.xmlsoap.org/ws/2002/12/secext"
    xmlns:ebl="urn:ebay:apis:eBLBaseComponents"
    xmlns:ns="urn:ebay:api:PayPalAPI">
3.    <SOAP-ENV:Header>
4.      <Security xmlns="http://schemas.xmlsoap.org/ws/2002/12/secext"xsi:type="wsse:SecurityType"/>
5.      <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI" xsi:type="ebl:CustomSecurityHeaderType">
6.        <Credentials xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:UserIdPasswordType"/>
7.      </RequesterCredentials>
8.    </SOAP-ENV:Header>
9.    <SOAP-ENV:Body id="_0">
10.     <Specific-API-Operation-Name>-Response xmlns="urn:ebay:api:PayPalAPI">
11.       <Timestamp xmlns="urn:ebay:api:PayPalAPI">DateTime-In-UTC/GMT-Format</TIMESTAMP>
12.       <Ack xmlns="urn:ebay:apis:eBLBaseComponents">Success</Ack>
13.       <Version xmlns="urn:ebay:apis:eBLBaseComponents">API-Version</Version>
14.       <CorrelationId xmlns="urn:ebay:apis:eBLBaseComponents">Correlation-ID</CorrelationID>
15.       <Build xmlns="urn:ebay:apis:eBLBaseComponents">API-Build-Number</Build>
16.       <Elements-For-Specific-API-Response></Elements-For-Specific-API-Response>
17.     </Specific-API-Operation-Name-Response>
18.   </SOAP-ENV:Body>
19. </SOAP-ENV:Envelope>
Anotação de Resposta SOAP Genérica
Linhas Comente
10 a 17 Os elementos de início e fim. Um exemplo de uma operação da API é . Consulte a referência da API NVP / SOAP para obter uma lista completa.Specific-API-Operation-Name-ResponseSetExpressCheckout
11 Cada resposta da API contém uma Timestampdata e hora no formato UTC / GMT.
12 Ackelemento acknowledgement ( ) contém a string Successindicando que a solicitação correspondente foi processada com sucesso. Quando há um erro, ele Acké definido como um valor diferente de Successe o corpo da resposta contém um Errorselemento com informações para ajudá-lo a solucionar a causa do erro. Veja Respostas de erros para mais informações.
14 CorrelationIDelemento contém informações sobre o aplicativo do PayPal que processou a solicitação. Use o valor desse elemento se você precisar solucionar um problema com uma das suas solicitações.
16 As diferentes APIs do PayPal retornam elementos diferentes, dependendo de suas definições de resposta. Para informações detalhadas, consulte as descrições na referência da API .

Nota: Como um campo é definido na estrutura formal de uma resposta da API, isso não significa que o campo seja necessariamente retornado. Os dados são retornados em uma resposta somente se o PayPal registrou dados que correspondem ao campo.

Respostas de erro

Se o Ackvalor não for Success, o pagamento ou ação desejada pode não passar.

Os valores possíveis do Ackcampo de resposta são os seguintes:

  • Success – O pedido foi bem sucedido.
  • SuccessWithWarning – A solicitação foi bem-sucedida, mas um código de erro de aviso também foi retornado.
  • Failure– A solicitação da API falhou. Veja mensagens de erro para detalhes.
  • FailureWithWarning – A solicitação da API falhou e mensagens de aviso adicionais foram retornadas.

Se uma solicitação estiver mal formada ou contiver algum outro erro, o corpo da resposta SOAP conterá um Errorselemento com outros elementos que podem ajudá-lo a solucionar a causa do erro.

A estrutura das mensagens de erro é a seguinte:

O mais importante desses elementos adicionais é o seguinte:

  • ShortMessage
  • LongMessage
  • ErrorCode

Informações adicionais podem aparecer como parte de ErrorParametersType. Por exemplo, se a resposta retornada dentro do ParamIDelemento for ProcessorResponse, o Valueelemento conterá um erro específico do processador de placa de terceiros, como 0091. Os valores definidos no ErrorParametersTypenão são definidos pelo PayPal; em vez disso, eles são passados ​​da fonte.

Nota: o PayPal apenas transmite os valores selecionados em ErrorParametersType.

O exemplo a seguir mostra a resposta de erro se o nome de usuário e a senha da API não corresponderem a um nome de usuário e senha legítimos da API registrados no PayPal.

Exemplo da resposta de erro SOAP: Nome de usuário ou senha inválidos

<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV: Envelope [DETAILS NOT SHOWN]>
  <SOAP-ENV:Header>[DETAILS NOT SHOWN]</SOAP-ENV:Header>
  <SOAP-ENV:Body id="_0">
    <GetTransactionDetailsResponse xmlns="urn:ebay:api:PayPalAPI">
    <Timestamp xmlns="urn:ebay:apis:eBLBaseComponents">2005-02-09T21:51:26Z</Timestamp>
    <Ack xmlns="urn:ebay:apis:eBLBaseComponents">Failure</Ack>
    <Errors xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:ErrorType">
      <ShortMessage xsi:type="xs:string">Authentication/Authorization Failed</ShortMessage>
      <LongMessage xsi:type="xs:string">Username/Password is incorrect</LongMessage>
      <ErrorCode xsi:type="xs:token">10002</ErrorCode>
      <SeverityCode xmlns="urn:ebay:apis:eBLBaseComponents">Error</SeverityCode>
    </Errors>
    <CorrelationID xmlns="urn:ebay:apis:eBLBaseComponents">Debugging-Info</CorrelationID>
    <Version xmlns="urn:ebay:apis:eBLBaseComponents">124.00</Version>
    <Build xmlns="urn:ebay:apis:eBLBaseComponents">1.0006</Build>
    <...other elements="" in="" response...="">
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

CorrelationID para relatar problemas ao PayPal

O valor retornado CorrelationIDé importante para o PayPal determinar a causa precisa de qualquer erro que você possa encontrar. Se você tiver que solucionar um problema com suas solicitações, sugerimos que você capture o valor CorrelationIDpara que você possa denunciá-lo ao PayPal.

Codificação de caracteres UTF-8

A API do PayPal supõe que todos os dados nas solicitações estejam em Unicode, especificamente, o formato de codificação de 8 bits (UTF-8) Unicode (ou UCS) Transformation Format.

Nas respostas, a API sempre retorna dados em UTF-8.

Formatos de data / hora

O esquema da API do PayPal para o SOAP define valores de data / hora como Hora Universal Coordenada (UTC / GMT), usando o formato ISO 8601 e do tipo ns:dateTime.

Um exemplo de data / hora é 2006-08-24T05: 38: 48Z

Tipo de dados do valor da moeda central

O tipo de dados da quantia monetária principal é chamado BasicAmountTypee é derivado de string. Todos os campos de valor monetário têm a seguinte estrutura:

  1. currencyIDatributo é obrigatório.
  2. O valor deve ter duas casas decimais, exceto no caso de moedas que não suportam valores decimais .
  3. O separador decimal deve ser um período (“.”).
  4. Você não deve usar nenhum separador de milhares.
  5. BasicAmountTypetem um tipo de dados ebl:CurrencyCodeType, que define um grande número de diferentes códigos de moeda. No entanto, para que seu processamento seja bem-sucedido, você deve definir currencyCode como um código de moeda válido .

Exemplo

O nome do campo Amount, é um exemplo; os nomes dos campos reais podem variar dependendo da operação específica da API .

<Amount currencyCode="USD">3.00</Amount>


FONTE: https://developer.paypal.com/docs/classic/api/PayPalSOAPAPIArchitecture/

FrameTrail – Crie, Anote e Remix Vídeos interativos

FrameTrail é um software de código aberto que permite que você experimente, gerencie e edite vídeos interativos diretamente no seu navegador.
Permite-lhe hiperligar conteúdos fílmicos, incluir documentos multimédia adicionais (por exemplo, sobreposições de texto, imagens ou mapas interactivos) e adicionar materiais suplementares (anotações) em pontos específicos
Nos últimos 6 meses, o FrameTrail recebeu financiamento público pelo Ministério Federal da Educação e Pesquisa (BMBF), através do Prototype Fund, para desenvolver novas tecnologias e interfaces de anotação de vídeos . 
Desde então, muitas coisas mudaram, incluindo o formato de dados e até mesmo alguns dos conceitos fundamentais. A documentação e a página de demonstração ainda não foram atualizadas, então espere mais algumas semanas até começar a trabalhar com a nova versão (bis dahin wird endlich auch die Website auf Deutsch übersetzt sein). 
Se você quiser experimentar o FrameTrail imediatamente, baixe a versão DEVELOPMENT do GitHub.
Uma coisa não mudou: extraia o arquivo zip, faça o upload para o servidor e está pronto para ir.





Características

Documentos baseados no tempo

Use qualquer arquivo de vídeo ou mesmo um vídeo vazio com um comprimento definido como base para a sincronização.

Fragmentos de vídeo vinculados

Crie redes não-lineares de fragmentos de vídeo (Hypervideos) que possam ser navegadas livremente pelo usuário.

Superposições interativas

Coloque documentos no topo do vídeo (por exemplo, texto, imagens, páginas da web ou mapas interativos) e decida como e quando eles devem ser exibidos.

Anotações multimídia

Adicione materiais suplementares em certos pontos do tempo e compare aqueles com as linhas de tempo de anotação de outros usuários.





Videos interativos não são novidades : https://en.wikipedia.org/wiki/Interactive_movie (na verdade antes dos laser discs já se tinham iniciativas)
Projeto interessante:
https://github.com/OpenHypervideo/FrameTrail

Uma proposta de padronização:
https://github.com/memex/trails-proposal

Mas acredito que o 1º passo a ser dado com o frametrail é ter um player como o soundcloud dos videos.
 O objetivo é ter um player como esse:

 

L.IVE: Um ambiente de aprendizagem interativo baseado em vídeo integrado

Existem inúmeras iniciativas e estudos sobre interfaces (e interatividade nos atuais “live”), segue um exemplo:

 

Apresentamos o L.IVE: um ambiente de aprendizagem em linha interativo baseado em vídeo com um design e arquitetura alternativos que integrais três principais componentes de interface: vídeo, tópicos de comentários e avaliações. Isso contrasta com a abordagem das interfaces existentes que separam visualmente esses componentes. Nosso estudo, que compara L.IVE com ambientes de aprendizagem populares em vídeo baseados em vídeo, sugere vantagens nesta abordagem integrada, em comparação com a abordagem separada na aprendizagem.

 

FONTE:

http://sisdipe.com.br/i-educar/interno/player.php

https://frametrail.org/

Nosso Futuro da Memória Cultural Ameaçada

A indústria de manipulação de vídeo é uma bomba de tempo

Apornografia trocada, como muitos desenvolvimentos tecnológicos e sociais de nossa época, parece uma coisa ruim, mas é, de fato, muito, muito pior. Não é difícil concluir que os hobbyists de pornografia sintética, ajudando-se mutuamente ensinar-se a ensinar os computadores a colar as semelhanças de novas pessoas com o video pornográfico existente, estão fazendo algo violador; PornHub declarou que o produto resultante não é consensual e viola seus termos de serviço.

Mesmo que a perspectiva de aparecer involuntariamente em um vídeo de sexo incondicional é perturbadora em seus próprios termos, porém, é muito mais perturbador como um caso de teste, uma versão caseira barata do projeto maior e bem financiado de fazer um video plausível de coisas que nunca aconteceu – o que o Charlie Warzel, da BuzzFeed, descreveu este mês como “um potencial projeto de Manhattan de novidades falsas”.

A diferença entre a manipulação de vídeo e o projeto real de Manhattan é que os cientistas no Projeto Manhattan sabiam que eram membros do esforço de guerra e que seu objetivo era construir o dispositivo de morte mais poderoso do mundo. Uma vez que o construíram, os cientistas entenderam que eles mudaram o mundo de uma forma grave e terrível.

A indústria de manipulação de vídeos parece não ter consciência de tudo o que torna possível. Em uma apresentação do produto Adobe Photoshop a partir do final do ano passado, uma multidão aplaude enquanto os representantes da empresa demonstram como a tecnologia Adobe Cloak do projeto pode remover uma lamparina desagradável de um vídeo de uma catedral russa. Mas espere! Tem mais!

Para novos aplausos, os representantes continuam a exibir imagens de dois caminhantes passando por uma garganta , e o software remove uma correia de uma das suas mochilas. Isso pode remover as pessoas? “Sim, podemos – podemos remover as pessoas”, diz o apresentador. “Sim”. E as pessoas estão envolvidas em um contorno roxo, como um elemento visual indesejável, isolado e removido.

“Tudo o que sabemos sobre a nossa sociedade, ou mesmo sobre o mundo em que vivemos, sabemos através dos meios de comunicação”, escreveu Niklas Luhmann em seu livro The Reality of the Mass Media: Memória cultural no presente (1996). “Isto é verdade não só do nosso conhecimento da ciência e da história, mas também do nosso conhecimento da natureza. O que sabemos sobre a estratosfera é o mesmo que Platão sabe sobre a Atlântida: ouvimos dizer isso. “

Para viver assim, dependemos de palavras, sons e, especialmente, de imagens, em massa distribuídas mecanicamente. As coisas que aparecem no vídeo são mais reais do que as coisas sobre as quais simplesmente somos informados. Havia muitas boas razões para que o executivo de fast food, Andrew Puzder, não se tornasse secretário de trabalho, mas aquele que garantiu a derrota de sua indicação era a aparência de sua ex-esposa, disfarçada de uma peruca e grandes óculos tingidos, em uma fita de vídeo de um antigo episódio de Oprah sobre o abuso do casal.

As alegações de abuso haviam sido relatadas há muito tempo, juntamente com o fato de que ela as recuou no decurso de um acordo de custódia. Mas os visuais fizeram a diferença. Uma estranheza no escândalo, testemunhando o poder sobrenatural do formato, foi que a empresa que originalmente exibira o vídeo se recusou a cooperar com o esforço para encontrá-lo e torná-lo público. Oprah apresentou a imagem da mulher sob um pseudônimo, como representante do problema genérico ou escândalo de “mulheres maltratadas de classe alta”. Agora, porém, era evidência sobre uma pessoa específica e poderosa, uma coisa mais potente do que os produtores já quis criar.

Ele saiu de qualquer jeito, assim como a fita do Access Hollywood de Donald Trump pegou, apesar do desejo da NBC de caminhar lentamente pelas notícias. Nos 22 anos desde que Luhmann descreveu a inescapabilidade dos meios de comunicação de massa, os meios de comunicação de massa perderam um grande controle que eles gozavam como instituições. A produção e a disseminação foram fraturadas e tornaram-se participativas ou criaram novas simulações de alta velocidade de participação.

No entanto, o espaço em que os meios de comunicação funcionam continua sendo o único espaço que existe. Ainda não há outra maneira de saber nada sobre as escalas nas quais as coisas exigem ser conhecidas: a nação, o governo, a economia, o mundo, a cultura. Mas o conhecimento agora está quebrado e desestabilizado. Imagens e histórias podem ser distribuídas para grandes extensões do planeta por qualquer pessoa, ou podem ser distribuídas para um conjunto pequeno e restrito de pessoas. Na parte receptora, eles são vivenciados exatamente da mesma maneira.

Os colegas de rosto entendem isso como uma verdade, seja ou não ao nível de percepção. Para fins de produção de pornografia sintética, um ator de cinema principal e uma pessoa em um clipe de pornografia existem em um único plano de realidade ou irrealidade. Ambos são imagens em movimento, nada mais, para serem recebidos e consumidos. É a lógica amoral das próprias máquinas de aprendizagem: Aqui estão duas versões do mesmo tipo de entrada a serem retrabalhadas para uma nova saída desse mesmo tipo. Qualquer distinção de significado e valor – da realidade subjacente, como as pessoas podem querer entender – equivale a substituir facilmente metadados.

É fácil e sombrio pensar as possibilidades: observações escandalosas que um candidato político nunca pronunciou, confissões falsas, actos falsificados de violência. Tropas em diferentes uniformes, sob várias bandeiras, fazendo as mesmas coisas. As multidões inaugurais transbordam o Mall e empacotaram as várzeas da rota do desfile.

Ninguém realmente se propôs a demolir a realidade. Ninguém estabeleceu para inscrever a população mundial em um sistema de vigilância em tempo integral, também. Eles apenas criaram smartphones, e esses telefones precisavam manter contato com as redes de comunicação em torno deles. E cada vez mais serviços trocaram informações sobre movimento e uso e comportamento e atenção, e os telefones se tornaram plataformas de publicidade, e os anunciantes queriam saber o quanto pudessem sobre potenciais clientes – o que acabou por ser aproximadamente tudo.

E, da mesma forma, mesmo que algumas pessoas estejam construindo ferramentas para fazer vídeos de eventos que nunca aconteceram, outras pessoas estão construindo ferramentas para distribuir esse material através de canais separados, opacos e inexplicáveis. O Facebook funciona como um serviço de microtargeting sob a aparência de um vasto fórum público, para que ninguém possa dizer o que o Facebook de qualquer outra pessoa pode ter. Demorou meses de crise, uma eleição presidencial e as investigações federais antes que a empresa decidiu que começaria a trabalhar em formas de tornar as campanhas publicitárias visíveis e responsáveis . O Twitter oferece anúncios ligados a contas inexistentes do Twitter , por isso é impossível saber de onde elas vieram ou quem mais as viu. O contexto é tão inviável quanto o conteúdo.

Até agora, o susto de notícias falsas concentrou-se principalmente nos remetentes – agentes estrangeiros, russos, um inimigo escondido, mas que pode ser retratado. Mas o remetente está quase ao lado do ponto. O horror está em ser os destinatários, cada um de nós em uma realidade hermética, incapaz de confiar no que vemos ou de saber quais outras realidades podem estar ao nosso lado.

 

Fontehttps://medium.com/s/story/our-future-of-warped-cultural-memory-4598ab103b05

FERRAMENTA PENTEST – T50

T50 é uma ferramenta para DoS desenvolvida pelo brasileiro Nelson Brito, sendo de fácil uso.
O código fonte do T50 encontra-se no link abaixo:
Deve ser compilado (como root) em um terminal linux (pode ser qualquer um, eu uso o Debian como Distro) com make.
Para realizar uma simulação de DoS contra um determinado IP e uma determinada porta, digite no terminal:
./t50 –flood –turbo –S –p 80 192.168.1.1 –flood –turbo –S
A sintaxe para se usar o ataque de DoS “-p” indica que a porta 80 será atacada e 192.168.1.1 indica o IP da vítima – No exemplo o roteador.

 

https://sourceforge.net/projects/t50/files/latest/download

Instalando o Nota Fiscal de Serviços Eletrônica (NFS-e) a partir dos fontes no Linux

 

A Nota Fiscal de Serviços Eletrônica possui integração com entes públicos que utilizam o sistema e-Cidade, gerando cobranças automáticas no momento da emissão de guias e facilitando o processo de fiscalização. Além disso, o produto permite a integração com outros sistemas de gestão pública, visando sempre atender às necessidades dos nossos clientes.

1. Instalação do Ubuntu Server 16.04.x LTS

O Ubuntu Server é a versão do sistema operacional da Canonical voltada para servidores. Como o uso em servidores exige um tempo maior de suporte, a versão indicada para o uso com esta documentação é a Ubuntu Server 16.04.x LTS.

1.1 Obtendo a mídia de instalação

A mídia de instalação pode ser obtida diretamente do site da Canonical e gravada em CD, DVD ou pendrive. No site http://www.ubuntu.com/download/server esta disponível a versão mais recente, mas utilizaremos a versão 16.04.x LTS disponível em http://releases.ubuntu.com/xenial/ (ubuntu-16.04.2-server-amd64.iso) por questões de compatibilidade com o produto.

1.2 Instalando o Ubuntu Server 16.04.x LTS

O processo de instalação do sistema operacional não é coberto por esta documentação, mas recomendamos a instalação mínima padrão, em “pt_BR” Português do Brasil, somente com os softwares “standard system utilities” e “OpenSSH server”.

Dica: Maiores informações sobre a instalação e personalização do sistema operacional podem ser obtidas em:
https://help.ubuntu.com/16.04/serverguide/

1.3 Editando os arquivos de configuração

Durante o processo de configuração descrito nesta documentação, é necessário editar e modificar diversos arquivos de texto. Para realizar estas modificações, sugerimos a utilização do editor “nano”, mas você pode usar qualquer outro editor de texto de sua preferência.

Dica: Mais informações sobre o editor de textos “nano” podem ser obtidas em:
http://www.nano-editor.org/.

2. Instalação do PostgreSQL 9.5.x

PostgreSQL é um sistema gerenciador de banco de dados objeto relacional (SGBDOR), desenvolvido como projeto de código aberto sem custo de licença. Este é o programa que vai gerenciar e armazenar o banco de dados relacional utilizado pelo NFS-e.

Dica: Mais informações sobre o PostgreSQL podem ser obtidas em:
http://www.postgresql.org/.

2.1 Configurando o repositório

Para instalar o PostgreSQL 9.5.x e suas dependências, utilizaremos o gerenciador de pacotes apt, que nos prove as últimas atualizações dos pacotes requeridos através de um canal seguro e confiável.

2.1.1 Crie o arquivo pgdg.list através dos comandos abaixo.
[linux]$ sudo touch /etc/apt/sources.list.d/pgdg.list
[linux]$ echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Dica: Mais informações sobre a configuração do repositório podem ser obtidas em:
https://www.postgresql.org/download/linux/ubuntu/

2.1.2 Baixe e importe a chave de assinatura do repositório através do comando:
[linux]$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv ACCC4CF8

Dica: Mais informações sobre o gerenciador de pacotes “apt” podem ser obtidas em:
https://help.ubuntu.com/16.04/serverguide/package-management.html

2.2 Ajustando o idioma

Atenção: Este procedimento só é necessário se você não instalou o sistema operacional em “pt_BR” – Português do Brasil.

[linux]$ sudo apt -y install language-pack-gnome-pt language-pack-pt-base myspell-pt myspell-pt-br wbrazilian wportuguese

2.3 Instalando o PostgreSQL 9.5.x

Para realizar a instalação do PostgreSQL 9.5.x através do gerenciador de pacotes execute os comandos:

[linux]$ sudo apt update
[linux]$ sudo apt -y install postgresql-9.5 postgresql-client-9.5 postgresql-contrib-9.5

2.4 Criando e configurando o cluster

O NFS-e utiliza encoding UTF-8 no cluster do PostgreSQL 9.5.x. Por isso vamos parar, remover e recriar o cluster quer será utilizado pela aplicação.

Atenção: O NFS-e não pode ser instalado no mesmo cluster dos demais produtos como: e-cidade, e-cidadeonline, etc. A codificação utilizada pelo NFS-e é UTF-8, enquanto que nos outros produtos é LATIN1!

Dica: Mais informações sobre a configuração do cluster:
http://www.postgresql.org/docs/9.5/static/sql-cluster.html

2.4.1 Vamos parar o cluster criado pelo processo de instalação do PostgreSQL através do comando:
[linux]$ sudo pg_dropcluster --stop 9.5 main
2.4.2 Vamos criar o novo cluster do banco de dados como LATIN1 usando o comando:
[linux]$ sudo pg_createcluster -u postgres -g postgres -e UTF8 --locale="pt_BR.UTF-8" --lc-collate="pt_BR.UTF-8" 9.5 nfse
2.4.3 Para permitir o acesso de qualquer local ao banco de dados é necessário modificar o arquivo /etc/postgresql/9.5/nfse/pg_hba.conf usando o comando:
[linux]$ sudo nano /etc/postgresql/9.5/nfse/pg_hba.conf

Localize e altere as linhas do arquivo do arquivo de configuração que não estão comentadas (# na frente da linha), substituindo os valores correspondentes por trust, conforme a tabela abaixo.

local all postgres
local all all
host all all 127.0.0.1/32
host all all ::1/128
2.4.4 Para a correta integração com o NFS-e, é necessário alterar algumas configurações do cluster criado através do comando:
[linux]$ sudo nano /etc/postgresql/9.5/nfse/postgresql.conf

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere as linhas do arquivo do arquivo de configuração, descomentando-as se necessário (remover o caractere # do início da linha), substituindo os valores correspondentes conforme a indicação abaixo.

listen_addresses = '*'
max_connections = 20
2.4.5 Inicie o servidor PostgreSQL através do comando:
[linux]$ sudo systemctl start postgresql.service
2.4.6 Verifique o resultado da configuração usando o comando:
[linux]$ psql -U postgres -h localhost -l

A saída do comando deve ser parecida com os valores abaixo.

   Nome    |   Dono   | Codificação |     Collate      |      Ctype       | Privilégios de acesso
-----------+----------+-------------+------------------+------------------+-----------------------
 postgres  | postgres | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      |
 template0 | postgres | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres
 template1 | postgres | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres

2.5 Criando a estrutura de banco de dados para o NFS-e

Vamos criar os usuários necessários para o funcionamento do NFS-e através dos comandos:

Atenção: Em ambientes de produção, nunca utilize senhas que tenham o mesmo nome da conta de usuário. Mais informações sobre segurança de senhas podem ser obtidas em:
http://cartilha.cert.br/senhas/.

psql -U postgres -c "CREATE ROLE nfse WITH SUPERUSER LOGIN PASSWORD 'nfse';"

Em seguida, utilize o comando abaixo para criar o banco de dados:

psql -U postgres -c "CREATE DATABASE nfse OWNER nfse;"

3. Instalação do Apache

Apache é o servidor web mais usado em sistemas Linux. Servidores web são usados para servir páginas Web que, normalmente, são solicitadas pelos computadores clientes através de navegador, como o Firefox, Chromium, etc.

Dica: Mais informações sobre o Apache podem ser obtidas em:
http://www.apache.org/.

3.1 Instalando o Apache

Para realizar a instalação do servidor web Apache através do gerenciador de pacotes, execute o comando:

[linux]$ sudo apt -y install apache2

3.2 Configurando a diretiva VirtualHost

3.2.1 Faça uma cópia de segurança do arquivo de configuração padrão, que é criado pelo Apache durante o processo de instalação através do comando:
[linux]$ sudo cp -a /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/000-default.conf.dist
3.2.2 Para a correta integração com o NFS-e, é necessário adicionar alguns parâmetros ao arquivo de configuração do VirtualHost através do comando:
[linux]$ sudo nano /etc/apache2/sites-available/000-default.conf

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Adicione as linhas que não existirem e edite as existentes dentro do bloco VirtualHost, conforme é exibido abaixo.

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html/nfse/public

  SetEnv APPLICATION_ENV "production"
  SetEnv no-gzip 1

    <Directory /var/www/html/nfse/public>
        DirectoryIndex index.php
        Options -Indexes +FollowSymLinks +MultiViews
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error-nfse.log
    CustomLog ${APACHE_LOG_DIR}/access-nfse.log combined

</VirtualHost>

Dica: Mais informações sobre o VirtualHost podem ser obtidas em:
http://httpd.apache.org/docs/current/vhosts/examples.html.

4. Instalação do PHP 5.6 e PHP-FPM

PHP é uma linguagem interpretada livre, usada originalmente apenas para o desenvolvimento de aplicações presentes e atuantes no lado do servidor, capazes de gerar conteúdo dinâmico na World Wide Web.

O PHP-FPM é uma alternativa ao PHP FastCGI com muitas funcionalidades voltadas a sites com grande número de acessos e carga.

Dica: Mais informações sobre o PHP e PHP-FPM podem ser obtidas em:
http://www.php.net/ e http://php-fpm.org/

4.1 Configurando o repositório

Para instalar o PHP 5.6 e suas dependências, utilizaremos o gerenciador de pacotes apt, que nos prove as últimas atualizações dos pacotes requeridos através de um canal seguro e confiável.

4.1.1 Instale o repositório PPA através dos comandos abaixo.
[linux]$ sudo apt-add-repository -y ppa:ondrej/php
[linux]$ sudo apt update

4.2 Instalando o PHP 5.6 e o PHP-FPM

Para realizar a instalação do PHP 5.6 através do gerenciador de pacotes, execute o comando:

[linux]$ sudo apt -y install php5.6 php5.6-bcmath php5.6-bz2 php5.6-cli php5.6-common php5.6-curl php5.6-gd php5.6-interbase php5.6-json php5.6-mbstring php5.6-mcrypt php5.6-pgsql php5.6-soap php5.6-sqlite3 php5.6-xml php5.6-xmlrpc php5.6-zip php5.6-fpm

4.3 Configurando o PHP 5.6 e o PHP-FPM

4.3.1 Habilitar as dependências de módulos através do comando:
[linux]$ sudo a2enmod proxy_fcgi setenvif rewrite
4.3.2 Habilitar as dependências de configuração através do comando:
[linux]$ sudo a2enconf php5.6-fpm
4.3.3 Configurar o arquivo de log do PHP-FPM através dos comandos:
[linux]$ sudo touch /var/log/php_errors.log
[linux]$ sudo chown www-data.www-data /var/log/php_errors.log
4.3.4 Para a correta integração com o NFS-e, é necessário alterar algumas configurações do PHP através do comando:
[linux]$ sudo nano /etc/php/5.6/fpm/php.ini

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere as linhas do arquivo do arquivo de configuração, descomentando-as se necessário (remover o caractere ; do início da linha), substituindo os valores correspondentes conforme a indicação abaixo.

short_open_tag = On
session.gc_maxlifetime = 7200
date.timezone = "America/Sao_Paulo"

Também é necessário alterar o arquivo de configuração utilizado pelo php-cli através do comando:

[linux]$ sudo nano /etc/php/5.6/cli/php.ini

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere as linhas do arquivo do arquivo de configuração, descomentando-as se necessário (remover o caractere ; do início da linha), substituindo os valores correspondentes conforme a indicação abaixo.

short_open_tag = On
date.timezone = "America/Sao_Paulo"
4.3.5 Reinicie o serviço do PHP-FPM usando o comando:
[linux]$ sudo systemctl restart php5.6-fpm.service

5. Instalação do NFS-e

5.1 Obtendo o pacote de instalação

O pacote de instalação pode ser obtido diretamente do site do Portal do Software Público. No endereço da comunidade do e-cidade (https://softwarepublico.gov.br/social/e-cidade) estão disponíveis as últimas versões e suas atualizações. Como estamos realizando uma nova instalação, você deve baixar o pacote completo, um exemplo de nome do pacote seria: e-cidadeonline2.completo.Vxxxxxx.tar.bz2.

5.2 Configurando o servidor

5.2.1 Vamos criar um usuário administrativo para o NFS-e, neste exemplo criaremos o usuário dbseller através do comando:
[linux]$ sudo useradd -d /home/dbseller -g www-data -G sudo,adm,cdrom,dip,plugdev -k /etc/skel -m -s /bin/bash dbseller
5.2.2 Em seguida, vamos definir uma senha para este novo usuário usando o comando:
[linux]$ sudo passwd dbseller

Dica: Neste exemplo, defina a senha como o mesmo nome de usuário, como “dbseller”.

Atenção: Em ambientes de produção, nunca utilize senhas que tenham o mesmo nome da conta de usuário. Mais informações sobre segurança de senhas podem ser obtidas em:
http://cartilha.cert.br/senhas/.

5.2.3 Também devemos corrigir a máscara de criação de arquivos modificando os arquivos através dos comandos:
[linux]$ sudo nano /etc/login.defs

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere a linha do arquivo do arquivo de configuração, descomentando-a se necessário (remover o caractere # do início da linha), substituindo o valor correspondente conforme a indicação abaixo.

UMASK           002

Em seguida, edite o arquivo de configuração de variáveis do apache com o comando abaixo:

[linux]$ sudo nano /etc/apache2/envvars

Adicione a linha abaixo no final do arquivo.

umask 002

5.3 Configurando o acesso do webservice no e-cidade

O NFS-e se comunica com o e-cidade através de um webservice, para que essa comunicação seja possível, é necessário liberar o acesso no e-cidade.

5.3.1 Liberando o acesso ao webservice do e-cidade

Após realizar o login no e-cidade, acesse:

  1. Selecione a instituição da prefeitura;
  2. Selecione o módulo DB:Configuração;
  3. Selecione o módulo Configuração;
  4. Selecione o menu Cadastros;
  5. Selecione o menu Cadastro de Acessos ao Sistema;
  6. Selecione o menu Inclusão;

Em seguida, preencha os campos conforme as instruções abaixo:

  1. No campo Data Início, selecione a data de hoje;
  2. No campo Hora Início, informe o valor 08:00;
  3. No campo Data Final, selecione uma data no futuro, como o valor 31/12/2099;
  4. No campo Hora Final, informe o valor 08:00;
  5. No campo Observação, informe o valor Acesso ao webservice pelo NFS-e;
  6. Clique no botão Incluir.

Após incluir o acesso, clique na aba Usuário e selecione no campo Cod. Usuário o usuário que será utilizado para comunicação com o webservice, em seguida, clique no botão Alterar.

Após incluir o usuário, clique na aba IP/Máscara e informe o valor no campo Máscara do IP o endereço IP do servidor do NFS-e que será utilizado para comunicação com o webservice do e-cidade, em seguida, clique no botão Alterar.

5.4 Instalando o NFS-e

5.4.1 Descompacte o pacote do NFS-e através do comando:
[linux]$ tar xjf e-cidadeonline2.completo.Vxxxxxx.tar.bz2
5.4.2 Copie o diretório do NFS-e para o diretório raiz do Apache usando o comando:
[linux]$ sudo cp -r e-cidadeonline2.completo.Vxxxxxx /var/www/html/nfse

5.5 Configurando o NFS-e

5.5.1 Crie o arquivo de configuração da aplicação através do comando:
[linux]$ sudo cp /var/www/html/nfse/application/configs/application.ini.dist /var/www/html/nfse/application/configs/application.ini

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]$ sudo nano /var/www/html/nfse/application/configs/application.ini

Em seguida, atualize as configurações conforme o exemplo abaixo.

...
doctrine.connectionParameters.dbname                    = "nfse"
doctrine.connectionParameters.host                      = "localhost"
doctrine.connectionParameters.password                  = "nfse"
doctrine.connectionParameters.port                      = "5432"
doctrine.connectionParameters.user                      = "nfse"
// Verifique a versão do sistema em /var/www/html/nfse/versao.txt
ecidadeonline2.versao                                   = "V011114"
resources.mail.transport.host                           = "smtp.exemplo.com"
resources.mail.transport.password                       = "nfse@exemplo.com"
resources.mail.transport.port                           = "587"
resources.mail.transport.username                       = "nfse@exemplo.com"
resources.mail.defaultFrom.email                        = "nfse@exemplo.com"
resources.mail.defaultFrom.name                         = "NFS-e Nome da Prefeitura"
settings.application.cache                              = "011114"
webservice.client.uri                                   = "http://url_acesso_ecidade/e-cidade/"
webservice.client.url                                   = "http://url_acesso_ecidade/e-cidade/"
webservice.client.location                              = "http://url_acesso_ecidade/e-cidade/webservices/requisicao.webservice.php"
// md5 do ID do usuário selecionado na regra de acesso do e-cidade
webservice.cliente.user                                 = "c4ca4238a0b923820dcc509a6f75849b"
...
5.5.2 Crie os arquivos de configuração do webservice através dos comandos:
[linux]$ sudo cp /var/www/html/nfse/application/configs/webservice-ecidade.ini.dist /var/www/html/nfse/application/configs/webservice-ecidade.ini

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]$ sudo nano /var/www/html/nfse/application/configs/webservice-ecidade.ini

Em seguida, atualize as configurações conforme o exemplo abaixo.

...
DB_id_usuario          = 'Id do usuário que criou a regra de acesso';
DB_login               = 'Login o usuário que criou a regra de acesso';
DB_ip                  = 'IP de acesso ao servidor do E-cidade';
SERVER_ADDR            = 'IP local do servidor do E-cidade';
SERVER_PORT            = 'Porta local do servidor do E-cidade';
DOCUMENT_ROOT          = 'Diretório raiz do E-cidade ex: /var/wwww';
SERVER_ADMIN           = 'e-mail do administrador do servidor web';
PHP_SELF               = 'webservices/requisicao.webservice.php';
HTTP_HOST              = 'Nome do host do E-cidade ex localhost';
...
[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/producao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/producao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/homologacao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/homologacao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/integracao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/integracao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

5.5.3 Ajuste as permissões dos diretórios através dos comandos:
[linux]$ sudo chown -R dbseller.www-data /var/www/html/nfse
[linux]$ sudo chmod -R 775 /var/www/html/nfse

Em seguida, limpe qualquer cache existente através do comando:

[linux]$ sudo rm -rf /var/www/html/nfse/application/data/Proxy/*
5.5.4 Faça a carga do schema do NFS-e através do comando:
[linux]$ cd /var/www/html/nfse
[linux]$ php bin/ruckus.php db:migrate
5.5.5 Reinicie o serviço do Apache usando o comando:
[linux]$ sudo systemctl restart apache2.service

5.6 Acessando o NFS-e

Após finalizar os procedimentos de instalação e configuração, abra um navegador e acesse o NFS-e através do endereço IP ou nome do servidor. EX: http://nfse.prefeitura.gov.br/, utilize como nome de usuário admin, e e como senha 123456.

Atenção: Altere a senha ao realizar o primeiro acesso. Mais informações sobre segurança de senhas podem ser obtidas em: http://cartilha.cert.br/senhas/.

Glossário

Termo Significado
encoding http://en.wikipedia.org/wiki/Character_encoding
cluster http://www.postgresql.org/docs/8.2/interactive/creating-cluster.html
apt-get http://www.debian.org/doc/manuals/apt-howto
apt-get http://pt.wikipedia.org/wiki/Advanced_Packaging_Tool
nano http://www.nano-editor.org
Firefox http://www.mozilla.org/firefox
DBSeller Sistemas http://www.dbseller.com.br
proxy http://pt.wikipedia.org/wiki/Proxy
squid http://pt.wikipedia.org/wiki/Squid

ALLEN ATLAS CEREBRAL

Visão geral

Esta base de dados de células cerebrais é uma pesquisa de características biológicas derivadas de dados de células únicas, de humanos e ratos.

O banco de dados contém propriedades eletrofisiológicas , morfológicas e transcriptômicas coletadas de células individuais e modelos simulando atividade celular. Nesta fase inicial da geração de dados, a cobertura da pesquisa foi focada em áreas selecionadas do córtex cerebral e nos neurônios talâmicos.

Procure os dados de resposta eletrofisiológica e as morfologias neuronais reconstruídas usando a ferramenta de Pesquisa de Caracteres Celulares . Os dados transcriptômicos podem ser acessados ​​através da página de download .

Use o Kit de Desenvolvimento de Software Allen (SDK) para acessar e analisar programaticamente dados em bruto e executar modelos.

Os dados podem ser baixados selecionando experimentos individuais na ferramenta de Pesquisa de Caracteres de Celular, acessando arquivos RNA-Seq transcriptômicos através da página de Download , ou através do SDK ou API Allen

 

 

 

Dados de rato

As células são adquiridas de áreas cerebrais selecionadas em ratos adultos. As células são identificadas para o isolamento com base em linhas de ratos transgênicos que abrigam repórteres fluorescentes conduzidos por drivers específicos do tipo celular. Para análises eletrofisiológicas e morfológicas, foram selecionadas células excitatórias com expressão enriquecida em camada e células inibitórias baseadas em marcadores clássicos. As áreas cerebrais selecionadas para análise incluem sub-regiões do córtex visual, córtex motor e córtex motor lateral anterior (ALM), na área do motor secundário (MOs).

Para a análise transcriptômica, foram realizadas dissecções regionais e laminares em espécimes de linhas transgênicas pan-neuronais, pan-excitatórias e pan-inibitórias, para amostra de forma abrangente. Os dados do núcleo geniculado lateral (LGd) também estão incluídos.

Este diagrama interativo de Venn mostra quantas células estão disponíveis para cada modalidade de dados (eletrofisiologia, morfologia, transcriptômica) e modelos. Selecione uma categoria para visualizar o subconjunto de células.

Existem 1058 células de mouse para as quais temos dados de eletrofisiologia.

 

 

Dados humanos

As células são adquiridas a partir do tecido cerebral doado nos lobos temporais ou frontais com base em anotações estruturais descritas no Atlas de referência do cérebro humano Allen . Para análises eletrofisiológicas e morfológicas no córtex, as células são selecionadas com base na forma do soma e na localização laminar.

Para a análise transcriptômica, diferentes camadas de córtex são dissecadas e os núcleos neuronais são isolados. A amostragem laminar é guiada pelo número relativo de neurônios presentes em cada camada.

 

 

 

Sobre eletrofisiologia

As gravações de grampos de patch de células inteiras fornecem informações básicas sobre propriedades de disparo celular. As gravações são realizadas usando uma variedade de protocolos de estímulo, incluindo pulsos curtos, passos longos, rampas lentas e ruído naturalista para caracterizar as propriedades intrínsecas desses neurônios. Os protocolos detalhados são descritos no whitepaper técnico de visão geral de eletrofisiologia .

Sobre Morfologia

A estrutura celular informa a função e a diversidade neuronal. Para ver a forma da célula, as células são preenchidas com biocitina e imagens em série para visualizar suas morfologias. Imagens planar e reconstruções de células 3D podem ser visualizadas com os dados de eletrofisiologia da célula, ou baixados para análise off-line. Os protocolos detalhados são descritos no whitepaper técnico da síntese de morfologia .

Sobre Transcriptomics

A seqüência de ARN pode fornecer um perfil transcriptômico para cada célula. Os transcritos genéticos são isolados, amplificados e seqüenciados, e as leituras estão alinhadas com um genoma de referência. A expressão de ARN por gene é relatada como uma média de isoformas de transcrição. Os dados estão disponíveis para células inteiras e, em alguns casos, isolados de frações nucleares. Para os núcleos, uma proporção significativa de lições se alinha aos intrões. Todos os dados podem ser baixados e os protocolos detalhados são descritos no quadro técnico geral da transcriptomics .

Sobre Modelos

Uma variedade de modelos neuronais que simulam propriedades de células intrínsecas estão disponíveis. Os modelos incluem: modelos generalizados de injeção e fogo, modelos biofisicamente realistas, de neurônio único com dendritos passivos e soma ativo (perisomático) e com condutâncias ativas (tudo ativo). As simulações podem ser vistas em linha ao lado das respostas celulares medidas, quando disponíveis. Todos os modelos podem ser baixados, e protocolos detalhados são descritos nos whitepapers técnicos: GLIF , perisomatic , all-active .

 

Fonte:  http://celltypes.brain-map.org/

Como implementar o Blockchain em JavaScript

Ouvimos falar sobre Bitcoin, Ethereum além de outras moedas praticamente todos os dias. 2017 afinal, foi o ano dascryptocurrencies.

Nesse post porém, não vou focar em nenhuma dessas moedas digitais. Mas sim na tecnologia por trás delas, que muitas pessoas dizem ser tão revolucionárias quanto a própria internet, o Blockchain.

A ideia é implementar passo-a-passo uma versão simplificada do Blockchain em JavaScript e ir explicando como essa tecnologia disruptiva funciona por baixo dos panos.

Então, continue lendo esse post para aprender:

  • O que é e como funciona o Blockchain
  • Proof of Work?
  • Pra que servem os Blocos
  • O que é Mineração

Introdução

O Blockchain parece uma tecnologia de outro mundo e gera muitas dúvidas. Apesar disso, é algo extremamente fácil de definir:

O Blockchain nada mais é do que um banco de dados aberto e distribuído.

Esse banco de dados é composto de Blocos. E todos esses Blocos são ligados entre si em uma sequência. Daí o nome, Blockchain (cadeia de blocos).

Além disso, esse banco de dados é imutável.
E faz sentido que seja.

Imagina se fosse possível que alguém intencionalmente modificasse sua conta. Agora os 10 Bitcoins que você possui viraram 1.

Blocos

Vamos começar a implementação pela parte mais fácil: os Blocos. A estrutura de um Bloco deve possuir os seguintes campos:

  • index
  • timestamp
  • hash
  • previousHash
  • data

Crédito: https://medium.com/@lhartikk/a-blockchain-in-200-lines-of-code-963cc1cc0e54

index e o timestamp são campos comuns em praticamente todos bancos de dados. O campo data serve principalmente pra guardar transações mas podemos também colocar outras informações. O hash é calculado internamente e serve pra manter a integridade de cada Bloco e a segurança de todo o sistema (como vamos ver no final do post). E por final, o previousHash é o elo de ligação que liga cada Bloco ao seu Bloco anterior.

Com isso, temos a primeira implementação de um Bloco:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.hash = this.generateHash()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp).toString()
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

A função generateHash usa a biblioteca externa crypto-js pra gerar o hash seguindo o padrão sha256.

Parece complicado, mas tudo o que você precisa saber é que essa função vai receber uma string como por exemplo:

foo

E vai retornar uma string encriptada:

2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae

Blockchain

Agora que já temos uma versão mínima de um Bloco, já podemos começar a construir o Blockchain, que como falei anteriormente é uma sequência de Blocos ligados entre si.

Com isso, essa é a primeira versão do Blockchain:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

No construtor da classe, temos o array de Blocos inicializado já com o Genesis Block (o primeiro bloco criado no registro do Bitcoin). Adicionei também o index para poder incrementar toda vez que um novo Bloco for adicionado no Blockchain.

Além disso duas funções foram criadas:

  • getLastBlock
  • addBlock

A primeira é extremamente simples, ela serve pra pegar o último Bloco que foi criado.

A segunda é uma pouco mais complicada, mas também não é nada de outro mundo. Ela serve pra adicionar novos Blocos ao Blockchain.

Integridade

Apesar de a versão anterior já funcionar razoavelmente bem, precisamos adicionar alguma garantia de que o Blockchain não tenha sido alterado por algum ataque malicioso.

Precisamos adicionar uma nova função para checar a integridade do Blockchain:

isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}

Lembrando que para verificarmos a integridade do Blockchain precisamos garantir três características:

  • hash de cada Bloco foi gerado corretamente
  • index dos Blocos está em sequência
  • Os Blocos estão ligados entre si através dos hashes

Com essa simples função podemos testar se modificações maliciosas foram feitas e se o Blockchain deve ser invalidado:

const Blockchain = require(./blockchain)
const blockchain = new Blockchain()
blockchain.addBlock({ amount: 4 })
blockchain.addBlock({ amount: 50 })
console.log(blockchain.isValid()) // true
blockchain.blocks[1].data.amount = 30000 // ataque malicioso
console.log(blockchain.isValid()) // false

E finalmente com isso já temos uma primeira versão básica e funcional do Blockchain em JavaScript:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

Problemas

Apesar de já termos uma versão inicial funcionando, ainda podemos melhorar bastante a nossa implementação.

Um dos problemas com essa versão atual é que usuários podem criar novos Blocos de forma muito rápida, podendo invalidar o Blockchain, ou coisas ainda piores. Não vou entrar em muitos detalhes dessa particularidade da tecnologia, mas o post abaixo faz um excelente trabalho nesse sentido:

Explaining blockchain — how proof of work enables trustless consensus

Em resumo, precisamos de alguma ferramenta que não permita que usuários possam criar Blocos desenfreadamente.

Proof of Work

O conceito de Proof of Work, como o próprio nome já sugere, é um mecanismo que faz com que um usuário tenha um trabalho computacional significativo ao realizar determinada tarefa.

Essa ferramenta já era utilizada antes do Bitcoin ser inventado para evitar por exemplo spams e ataques DoS.

No Bitcoin, o Proof of Work funciona da seguinte forma: o hash que é gerado automaticamente em cada Bloco deve começar com uma quantidade X de zeros, dependendo da dificuldade geral do sistema.

Por exemplo, se a dificuldade geral do sistema for 1, esse hash é inválido porque não começa com um zero:

a5036427617139d3ad9bf650d74ae43710e36d4f63829b92b807da37c5d38e8d

Porém, esse outro hash é válido porque começa com um zero:

07da8bff6cfea68a3f0a5bafc9b24d07f503e2282db36ffb58d43f9f4857c54b

Sempre que um usuário for criar um novo Bloco, ele vai precisar criar diversos hashes até que um deles tenha a quantidade de zeros no começo fazendo com que a regra geral do sistema seja atendida.

Ah, o nome disso é Mineração.

Lembrando que quanto maior o número de zeros que devem estar no começo do hash, maior o poder computacional necessário para a tarefa.

Dito isso, vamos agora implementar a versão final do Blockchain com a mineração.

Primeiramente vamos alterar os Blocos.

class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
/* */
}
view rawblock.js hosted with ❤ by GitHub

No construtor, adicionamos os campos difficulty (dificuldade geral do sistema) e nonce (quantidade de tentativas até que o hash correto seja criado). Além disso, temos também um chamada para a função mine.

mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
view rawblock.js hosted with ❤ by GitHub

A função mine vai criar hashes até que a quantidade de zeros à esquerda do hash seja atentida.

Lembrando que para que os hashes criados sejam diferentes, devemos adicionar o campo nonce na função generateHash:

generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
view rawblock.js hosted with ❤ by GitHub

Com isso temos a versão final do Blocos com a mineração:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

Agora basta alterarmos o Blockchain para que o campo difficulty seja passado para os Blocos:

const Block = require(./block)
class Blockchain {
constructor(difficulty = 1) {
this.blocks = [new Block()]
this.index = 1
this.difficulty = difficulty
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const difficulty = this.difficulty
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data, difficulty)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

E é só isso 🙂

Lembrando que o código está todo no GitHub.

Ah, se você quiser saber mais sobre o Blockchain:

Outras implementações:

Fonte: https://tableless.com.br/como-implementar-blockchain-em-javascript/?utm_source=tablelessRelatedLink

Web Speech API – Reconhecimento de voz com JavaScript

Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

O reconhecimento de voz tem várias aplicações no mundo real. Muitas pessoas tornaram-se familiarizadas com este conceito graças a softwares como o Siri e S-Voice. Esta aplicação pode melhorar drasticamente a usabilidade dos websites, principalmente para deficientes visuais. Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

 

 

O que é Web Speech API?

A Web Speech API foi lançada no final de 2012 e permite que os desenvolvedores forneçam a entrada de voz e recursos de saída de texto-para-voz em um navegador web. Esta API cuida da privacidade dos usuários, pois antes de deixar o site para acessar a voz através do microfone, o usuário deve explicitamente conceder a permissão. Curiosamente, o pedido de autorização é o mesmo que a API getUserMedia, apesar de não precisar da webcam. Se a página que executa esta API usa o protocolo HTTPS, o navegador solicita a permissão apenas uma vez.

 

 

Então veremos logo abaixo, um exemplo básico de como podemos implementar esta nova API aos nossos projetos:

Criando a primeira página com reconhecimento de voz:

Passo 1 – Estrutura HTML:

A estrutura HTML é bem simples, vejamos a marcação abaixo:

<p id="ola">Olá tableless, você falou:</p>

<button id=”rect”>Gravar</button> <span id=”unsupported” class=”hidden”>API not supported</span>

Onde:

  • Transcription – Onde se encontrará o texto informando oque o usuário falou
  • Rect – Botão para reconhecer a voz do usuário
  • unsupported – Caso a API não seja suportada pelo browser

Passo 2 – Testando

Como qualquer API, temos que verificar primeiramente se o browser suporta SpeechRecognition:

// Test browser support
window.SpeechRecognition = window.SpeechRecognition ||
window.webkitSpeechRecognition ||
null;

//caso não suporte esta API DE VOZ            
if (window.SpeechRecognition === null) {
    document.getElementById('unsupported').classList.remove('hidden');
}else {
    //......
}

Passo 3 – Métodos e propriedades

Depois de testar a compatibilidade da API, iremos instanciar o reconhecedor de  voz, usando o speechRecognition(). Como o código listado abaixo:

var recognizer = new window.SpeechRecognition();

Este objeto expõe os seguintes métodos:

  • onstart: Define um callback que é disparado quando o serviço de reconhecimento começou a ouvir o áudio com a intenção de reconhecer.
  • onResult: Define um callback que é disparado quando o reconhecedor de voz retorna um resultado.
  • onerror: Define um callback que é acionado quando ocorre um erro de reconhecimento de voz.
  • onend: Define um callback que é disparado quando o serviço foi desligado. O evento deve sempre ser gerado quando a sessão termina, não importa o que a razão.

Iremos criar uma varável que será responsável por exibir o texto que o usuário falou e também iremos definir a propriedade continuous = true, que faz com que o reconhecedor de voz não pare de ouvir, mesmo que tenha pausas do usuário.

var transcription = document.getElementById("transcription");

            //Para o reconhecedor de voz, não parar de ouvir, mesmo que tenha pausas no usuario
            recognizer.continuous = true;

Agora iremos definir a função “onresult” que define um callback que é disparado quando o reconhecedor de voz retorna um resultado.

recognizer.onresult = function(event){
                transcription.textContent = "";
                for (var i = event.resultIndex; i < event.results.length; i++) {
                    if(event.results[i].isFinal){
                        transcription.textContent = event.results[i][0].transcript+' (Taxa de acerto [0/1] : ' + event.results[i][0].confidence + ')';
                    }else{
                        transcription.textContent += event.results[i][0].transcript;
                    }
                }
            }

Vamos analisar este código um pouco mais detalhadamente:

transcription.textContent = “”;    Faz com que limpe o texto que se encontra dentro da “

for (var i = event.resultIndex; i < event.results.length; i++) {  Loop que pecorre o evento que contém o texto que o usuário falou.

Note que dentro deste loop, há uma condição, que verifica se o evento se encontra na última posição (event.results[i].isFinal), caso seja verdadeira, ele irá imprimir todo o texto, junto com a taxa de acerto, que vai de “0” até “1”. Caso seja falsa, ele vai adicionar mais texto na nossa div

Passo 4 – Anexando o evento de click

Agora iremos anexar um evento de click, ao nosso botão, segue 0 código abaixo :

document.querySelector("#rect").addEventListener("click",function(){
                try {
                    recognizer.start();
                  } catch(ex) {
                    alert("error: "+ex.message);
                  }
            });

Onde:

recognizer.start(); – Inicia o record ( a gravação );

catch(ex) {

alert(“error: “+ex.message);

} –  tratamento de log, caso exista, algum erro de gravação

É importante observarmos que o reconhecedor demora um pouco para poder interpretar a sua voz, mais ou menos uns 3 à 4 segundos, esta API ainda está em teste e que infelizmente até agora, só é  suportada no chrome,

Finalizando

Bem pessoal, essa foi uma breve introdução sobre Web Speech API. Futuramente irei trazer mais artigo

Disponibilizei o código no github e também disponibilizei uma demo.

Clique aqui para ver a demo online

Clique aqui, para ir ao código completo.

 

Fonte:https://tableless.com.br/web-speech-api-reconhecimento-de-voz-com-javascript/

 

 

 

 

 

Software para Windows de Eugene Muzychenko

Software comercial

Cabo de áudio virtual (VAC)

Driver de multimídia do Windows que cria um ” cabo virtual ” representado por dois dispositivos de forma de onda, entrada e saída, com ligação interna entre eles. Permite transferência de som direta e intocada entre diferentes aplicativos. Útil para gravar a saída de áudio do aplicativo em tempo real e salvar um fluxo de som de saída de aplicativos que não permitem gravá-lo diretamente no arquivo WAV. VAC é uma “versão de onda” do “cabo de loopback MIDI”, como os drivers Loopback do MultiMid ou do Hubi . Ao contrário do Total Recorder, você pode simplesmente salvar o fluxo de áudio, o VAC permite rotear em tempo real.,Foobar2000 , AIMP , Audacity , Audition , Skype , Flex-Radio etc.).

Cabo de áudio virtual 4 páginas (XP / 2k3 / Vista / Win 7/8 / 8.1 / 10)

Cabo de áudio virtual 3 páginas (9x / ME / NT4 / 2k / XP / 2k3)

Software grátis

Wave Clone

Ferramenta multimídia do Windows para compartilhar as portas Wave (MME) entre várias aplicações. Traz um recurso multi-cliente para qualquer dispositivo Wave. O Wave Clone é uma “versão de onda” dos “complementos de múltiplos clientes MIDI”, como os drivers de Loopback do MultiMid ou do Hubi .

Página Wave Clone (9x / ME / NT4 / 2k / XP / 2k3)

 

Manuais MIDI

Permite dividir seu teclado MIDI em dois manuais independentes (zonas), atribuir-lhes diferentes instrumentos MIDI e tocar as duas mãos ao mesmo tempo, produzindo peças de duas partes. Você não pode fazer isso usando um software de sequenciador popular.

Página de Manuales MIDI  (todos os sistemas)

 

FlushVol

Utilitário para liberar, uma vez ou periodicamente, buffers de arquivos de volume. Funciona como sync.exe de Mark Russinovich, mas enumera todos
os volumes fixos, incluindo montado em NTFS Mount Points . Pode ser instalado como um serviço para iniciar automaticamente e liberar buffers de volume com uma interfal dada.

Baixe FlushVol 1.4.2 (2k / XP / 2k3 / Vista / Win7 / 8/10 )

 

mscetool

O mscetool opera com o arquivo de cabeçalho MSCE dos arquivos WinCE CAB (um arquivo com extensão .000 que descreve o processo de instalação). O principal objetivo desse utilitário é mudar a arquitetura e / ou os campos do número de versão do WinCE no cabeçalho. Existem muitos programas que podem funcionar sob versões específicas do WinCE, mas são distribuídos em arquivos CAB com uma arquitetura forte e os números de versão mínima / máxima especificados.

Faça o download do mscetool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

b000fftool

O b000fftool opera com arquivos de imagem gravados MS B000FF (MSBIN) contendo imagens do Windows CE / ROM móvel. Pode ser útil para corrigir valores de endereço de carga incorretos em imagens CE6 BIN produzidas por BOOOFF, XipPort, Remaker e ferramentas similares.

Baixe o b000fftool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

tcctoolce

O tcctoolce executa algumas operações específicas para os dispositivos baseados em CPU ARCH da Telechips sob o WinCE (apenas a implementação de imagens instantâneas está implementada).

Baixe tcctoolce 1.0.1 (WinCE 4.2 ou superior)

 

TaskbarControlCE

TaskbarControlCE destina-se a controlar a aparência da barra de tarefas do Explorer em caso de alternar entre janelas normais e em tela cheia. Inicialmente desenvolvido para a estação multimídia do carro Createc / Joy-J-2619.

Baixar TaskbarControlCE 1.0.1 (WinCE 4.2 ou superior)

 

Driver SiLabs CP210x VCP para WinCE 4.2

Um driver VCP (Virtual Communication Port) para CP210x (CP2101, CP2102, CP2103, CP2104), chips USB para Serial Bridge fabricados pela Silicon Laboratories (anteriormente Cygnal). O driver cria COMn: porta serial virtual disponível para qualquer aplicativo de comunicação serial (emuladores de terminal, software de navegação GPS, etc.).

O driver funciona apenas em CPUs ARMV4 no Windows CE 4.2 (por exemplo, Windows Mobile 2003 SE ou Pocket PC 2003). Os drivers do CE 5.0 e 6.0 estão disponíveis no site do SiLabs .

Baixe cp210xvcp_ce42_2_0_1_0 (CE 4.2)

 

shrinkvd

shrinkvd é um utilitário de linha de comando para encadear arquivos de disco virtual VMware pré-alocados de acordo com um espaço realmente ocupado por partições. Útil para otimizar os hóspedes do Vista / Win7 / Win8.

Baixar shrinkvd 1.2 (todos os sistemas PC Windows)

 

pegue a senha

getpassword é um utilitário de linha de comando para solicitar uma senha do teclado, escondendo a entrada e retornando via saída padrão (por exemplo, para um arquivo de comando / lote).

Baixe o getpassword 1.0 (todos os sistemas PC Windows)

 

getfileinfo

getfileinfo é um utilitário de linha de comando para extrair e imprimir várias informações de arquivo (data, hora, versão, especificação). Os resultados da versão do arquivo podem ser úteis para criar nomes de arquivos versionados. Os qualificadores de especificação de arquivo podem ser úteis para extrair substituição de argumento de unidade, caminho, nome e extensão, como o processador de lote (cmd.exe), mas sem expandir caracteres curiosos para nomes de arquivos existentes. As peças de especificação extraídas contendo curingas podem ser usadas para processamento posterior de arquivos.

Baixe o getfileinfo 1.9 (todos os sistemas PC Windows)

 

MixerInfo

MixerInfo mostra todas as informações sobre um mixer de áudio fornecido.

Baixar MixerInfo (com código fonte)

 

ArrangeChildren

ArrangeChildren destina-se a organizar várias janelas filho na área de cliente da janela MDI do aplicativo. Ele pode ser usado para arrumar janelas de projeto em IDEs (ambientes de desenvolvedores integrados), como Visual Studio , Sound Forge , Photoshop e outros.

Download ArrangeChildren 1.00

Baixe ArrangeChildren 1.04

 

CopyFileFragm

CopyFileFragm é um utilitário de console destinado a manipular fragmentos de arquivos binários e expandir / encolher arquivos. Pode extrair um fragmento de arquivo para outro arquivo ou stdout, escrever um fragmento em outro arquivo no lugar, substituir / expandir arquivos etc.

Baixar CopyFileFragm 1.11

 

copywobuf

copywobuf é um utilitário de linha de comando do console que copia um arquivo (sem curingas), abrindo arquivos de origem e de destino com
FILE_FLAG_NO_BUFFERING para impedir o armazenamento em cache de arquivos. É útil copiar arquivos de / para pastas compartilhadas em convidados da VMware para evitar o bloqueio do arquivo host pelo processo vmware-vmx.exe.

Baixe copywobuf 1.3

 

waveinfo

waveinfo é um utilitário de linha de comando do console que mostra informações sobre arquivos RIFF / WAVE (.wav).

Baixe o waveinfo 1.3

VMWRefresh

O VMWRefresh permite que você use o SoftICE 3.x ou 4.x no Windows 2000 / XP executado no VMWare 4.5.1 forçando a janela de convidado do VMWare a atualizar periodicamente.

Faça o download do VMWRefresh 1.04

 

picoc para Win32

Picoc é um intérprete de linguagem C muito pequeno, projetado para sistemas baseados em UNIX. Existe uma porta para Win32 (x86 / x64).

Baixar picoc para Win32 2,2 m

 

RASPPPoE 0.98b patch de tempo limite

Um patch para os drivers do protocolo RASPPPeE escrito por Robert Schlabbach . Aumenta RASPPPoE tempo limite para 120..150 segundos para permitir sessão PPP a persistir durante a reconexão modem DSL.

Baixe o patch de tempo limite RASPPPo 0.98b

 

Fonte: http://software.muzychenko.net/eng/

DNALinux – Uma solução Linux para Bioinformática

Programas de bioinformática incluídos no DNALinux

 

 

O ApE- A Plasmid Editor
Funciona no Windows (testado em 98, XP, NT), OS X (10.3, 10.4 e 10.5) e Linux / Unix, destaca sites de restrição na janela de edição, mostra tradução, Tm,% GC, ORF de DNA selecionado em tempo real, lê os arquivos DNA Strider, Fasta, Genbank e EMBL, copiar e salvar gráficos como metarquivos do Windows (somente MS Windows) em outros recursos. Para mais informações, visite o website.

Web site: http://www.biology.utah.edu/jorgensen/wayned/ape/

Outros documentos:

Citação:

AutodockSuite 4.0.1

AutoDock é um conjunto de ferramentas de encaixe automatizadas. Ele é projetado para prever como pequenas moléculas, como substratos ou medicamentos candidatos, se ligam a um receptor de estrutura 3D conhecida. O AutoDock consiste de dois programas principais: AutoDock executa o encaixe do ligando para um conjunto de grades descrevendo a proteína alvo; O AutoGrid pré-calcula essas grades. Além de usá-los para encaixe, as redes de afinidade atômica podem ser visualizadas. Isso pode ajudar, por exemplo, a orientar químicas sintéticas orgânicas para designar melhores aglutinantes.

Web site: http://autodock.scripps.edu/

Outra documentação:

Citação: Morris GM, Goodsell DS, Huey R, Olson AJ. Distribuição automated docking de ligandos flexíveis para proteínas: aplicações paralelas do AutoDock 2.4. J Comput Aided Mol Des. 1996 Ago; 10 (4): 293-304. Pubmed


O Biopython é um conjunto de ferramentas livremente disponíveis para computação biológica escrita em Python por uma equipe internacional de desenvolvedores.
É um esforço colaborativo distribuído para o desenvolvimento de bibliotecas e aplicações Python que abordam as necessidades dos trabalhos atuais e futuros em bioinformática. O código fonte está disponível sob a licença Biopython, que é extremamente liberal e compatível com quase todas as licenças do mundo. Trabalhamos junto com a Open Bioinformatics Foundation, que generosamente fornece espaço na web e CVS para o projeto.

Web site: www.biopython.org

Outra documentação: Bassi S (2007) A Primer on Python for Life Science Researchers. PLoS Comput Biol 3 (11): e199. doi: 10.1371 / journal.pcbi.0030199 
Python para Bioinformáticalivro de Sebastian Bassi

Citação: Cock PJ, Antao T, Chang JT, Chapman BA, Cox CJ, Dalke A, Friedberg I, Hamelryck T, Kauff F, Wilczynski B e Hoon MJ. Biopython: ferramentas Python livremente disponíveis para biologia molecular computacional e bioinformática. Bioinformática 2009 1 de junho; 25 (11) 1422-3. doi: 10.1093 / bioinformática / btp163 pmid: 19304878. Pubmed

 

Blast 2.2.20

A Ferramenta de Pesquisa de Alinhamento Local Básico (BLAST) encontra regiões de similaridade local entre sequências. O programa compara sequências de nucleotídeos ou proteínas para bases de dados de sequências e calcula a significância estatística dos fósforos. O BLAST pode ser usado para inferir relações funcionais e evolutivas entre sequências, bem como ajudar a identificar membros de famílias de genes.

Site: http://blast.ncbi.nlm.nih.gov/

Outros documentos:

Citação: Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer, Jinghui Zhang, Zheng Zhang, Webb Miller e David J Lipman (1997), “Gapped BLAST e PSI-BLAST: uma nova geração de programas de pesquisa de banco de dados de proteína”, Nucleic Acids Res. 25: 3389-3402.

 

ClustalX

Alinhamento múltiplo de sequências de ácido nucleico e proteína.
Clustal X é uma interface do Windows para o programa de alinhamento de sequências múltiplas ClustalW. Ele fornece um ambiente integrado para realizar alinhamentos múltiplos de seqüências e perfis e analisar os resultados. O alinhamento da seqüência é exibido em uma janela na tela. Um esquema de coloração versátil foi incorporado, permitindo destacar os recursos conservados no alinhamento. Os menus pull-down na parte superior da janela permitem selecionar todas as opções necessárias para o alinhamento de múltiplas sequências e perfis tradicionais.

Site: http://www.clustal.org/

Outros documentos:

Citação: Jeanmougin, F., Thompson, JD, Gouy, M., Higgins, DG e Gibson, TJ (1998) Alinhamento de seqüências múltiplas com Clustal X. Tendências Biochem Sci, 23, 403-5.

 

O EMBOSS é “A Suite Européia de Software de Biologia Molecular Européia”. O EMBOSS é um pacote gratuito de análise de software de código aberto especialmente desenvolvido para as necessidades da comunidade de usuários de biologia molecular (por exemplo, EMBnet). O software lida automaticamente com dados em uma variedade de formatos e até permite a recuperação transparente de dados de sequência da web. Além disso, à medida que as extensas bibliotecas são fornecidas com o pacote, é uma plataforma para permitir que outros cientistas desenvolvam e liberem softwares com um verdadeiro espírito de código aberto. O EMBOSS também integra uma série de pacotes e ferramentas atualmente disponíveis para a análise de seqüências em um todo sem costura. O EMBOSS quebra a tendência histórica para pacotes de software comercial.

Web site: www.emboss.org

Outra documentação:

Citação: Arroz, P. Longden, eu. e Bleasby, A. EMBOSS: The European Molecular Biology Open Software Suite (2000) Tendências em Genética 16, (6) pp276-277.

 

EMNU-1.05
emnu exibe um menu simples baseado em caracteres que permite que você exiba os nomes dos programas em relevo e selecione-os. Ele também exibe os nomes dos arquivos em seu diretório atual e permite exibir seus conteúdos, copiá-los, excluí-los e fazer outras coisas com eles. Emnu permite mover os menus de programas ou arquivos usando as teclas de seta. Pressionando RETURN quando você selecionou um item executará um programa ou exibirá um arquivo.

Web site: http://web.mit.edu/emboss_v4.0.0/www/embassy/emnu/emnu.html

Outros documentos:

Citação:

ESIM4-1.0.0
Alinhar um mRNA a um

site de sequência de DNA genômico : http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/esim4/esim4.html

Outros documentos:

Citação: Florea L, Hartzell G, Zhang Z, Rubin GM, Miller W. “Um programa de computador para alinhar uma sequência de cDNA com uma sequência de DNA genômico”. Genoma Res 1998 Sep; 8 (9): 967-74

 

FinchTV – Visualizador de rastreamento de cromatografia de sequência de DNA. 
O utilitário FinchTV para visualização de arquivos de cromatograma é um aplicativo autônomo que os pesquisadores usam para visualizar e editar facilmente seus dados de seqüência com interatividade dinâmica.

Web site: http://www.geospiza.com/Products/finchtv.shtml

Outros documentos:

Citação:

HMMER-2.3.2 Os
modelos escondidos do Markov do perfil (HMMs do perfil) podem ser usados ​​para fazer pesquisa de banco de dados sensível usando descrições estatísticas do consenso de uma família de seqüência. HMMER é uma implementação livremente distribuível do software HMM de perfil para análise de seqüência de proteínas.

Web site: http://hmmer.janelia.org/

Outra documentação:

Citação: A teoria por trás do perfil HMMs: R. Durbin, S. Eddy, A. Krogh e G. Mitchison, análise de seqüência biológica: modelos probabilísticos de proteínas e ácidos nucleicos, Cambridge University Press, 1998. IPRSCAN-4.3.1 Web site: documentação adicional: Citação:

Kalign 2.03
Kalign é uma ferramenta de linha de comando para realizar o alinhamento múltiplo de seqüências biológicas. Ele emprega o algoritmo Wu-Manber string-matching, para melhorar tanto a precisão quanto a velocidade do alinhamento. Ele usa abordagem de alinhamento global e progressivo, enriquecendo empregando um algoritmo aproximado de correspondência de cadeias para calcular distâncias de seqüência e incorporando combinações locais no alinhamento de outra forma global. Nas comparações feitas por seus autores, Kalign era cerca de 10 vezes mais rápido do que o ClustalW e, dependendo do tamanho do alinhamento, até 50 vezes mais rápido do que os métodos iterativos populares.

Web site: http://msa.sbc.su.se/cgi-bin/msa.cgi

Outra documentação:

Citação: Timo Lassmann e Erik LL Sonnhammer. Kalign – um algoritmo de alinhamento de sequências múltiplo preciso e rápido. BMC Bioinformatics 2005, 6: 298doi: 10.1186 / 1471-2105-6-298

MEMENEW-0.1.0 Web site de
detecção de motivos

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/memenew/ememe.html

MIRA-2.8.2
O assembler do fragmento mira genome é um montador especializado para projetos de seqüenciamento classificados como “difíceis” devido ao alto número de repetições similares. Para transcrições de EST, miraEST é especializada na reconstrução de transcritos de ARNm prístinos enquanto detecta e classifica polimorfismos de nucleotídeos únicos (SNP) ocorrendo em diferentes variações.
O sistema de montagem está usando estratégias multipassos iterativas centradas no uso de regiões de alta confiança dentro de seqüências e tem uma estratégia de retorno para usar regiões de baixa confiança quando necessário.

Site: http://chevreux.org/projects_mira.html

 

MSE-1.0.0 Web site do 
Editor de Sequências Múltiplas

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/mse/mse.html

 

MYEMBOSS-6.0.0 O
MYEMBOSS fornece uma estrutura de diretório e stubs de makefile para desenvolver suas próprias aplicações mais facilmente do que em versões anteriores a 3.0.0.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/myemboss/

 

NCBI Toolkit

O NCBI Toolkit é uma coleção de utilitários desenvolvidos para a produção e distribuição do GenBank, Entrez, BLAST e serviços relacionados pelo Centro Nacional de Informação Biotecnológica. Inclui as ferramentas populares de bioinformática formatdb e blastall.

Web site: http://www.ncbi.nih.gov/IEB/ToolBox/SDKDOCS/INDEX.HTML

 

Polyxmass 0.9.7

PHYLIP (o pacote de inferência PHYLogeny) é um pacote de programas para inferir filogenias (árvores evolutivas). Está disponível gratuitamente na Internet e escrito para trabalhar em tantos tipos diferentes de sistemas de computador quanto possível.
Felsenstein, J. 2005. PHYLIP (Phylogeny Inference Package) versão 3.6. Distribuído pelo autor. Departamento de Ciências do Genoma, Universidade de Washington, Seattle.

Web site: http://evolution.gs.washington.edu/phylip.html

 

polyxmass é um conjunto de software para espectrometria de massa (bio) de polímero que é o Software Livre desenvolvido no GNU / Linux. Permite a definição de química de polímeros e a simulação / análise de dados espectrométricos de massa obtidos em (bio) polímeros.

Citação: Filippo Rusconi, GNU polyxmass: uma estrutura de software para simulações de espectrometria de massa de analitos lineares (bio-) poliméricos. BMC Bioinformatics 2006, 7: 226doi: 10.1186 / 1471-2105-7-226

 

Primer3 1.1.4 / Primer3plus (GUI da Web para primer3) O 
Primer3 é um programa amplamente utilizado para projetar iniciadores de PCR (PCR = “Reação em Cadeia de Polimerase”). O PCR é uma ferramenta essencial e omnipresente em genética e biologia molecular. O Primer3 também pode projetar sondas de hibridação e iniciadores de seqüenciamento.

Web site: http://primer3.sourceforge.net/

Outra documentação:

Citação: Rozen S, Skaletsky H (2000) Primer3 na WWW para usuários em geral e para programadores biologicos. Em: Krawetz S, Misener S (eds) Métodos e Protocolos de Bioinformática: Métodos em Biologia Molecular. Humana Press, Totowa, NJ, pp 365-386

 

Pymol 1.0r2 O
PyMOL é um sistema de visualização molecular de código aberto, criado por Warren Lyford DeLano e comercializado pela DeLano Scientific LLC, que é uma empresa de software privada dedicada à criação de ferramentas úteis que se tornam universalmente acessíveis para comunidades científicas e educacionais.

Site: http://www.pymol.org/

 

Rasmol 2.7.3.1
RasMol é um programa de gráficos moleculares destinado à visualização de proteínas, ácidos nucleicos e moléculas pequenas.

Site: http://www.rasmol.org/

 

 

readseq 1.7
Lê e grava seções nucleicas / proteínas em vários formatos. Os arquivos de dados podem ter múltiplas seqüências.

 

Sigma Align 1.1.1
A maioria das ferramentas para o alinhamento de sequências múltiplas são focadas no alinhamento da seqüência de proteínas ou da sequência de DNA que codifica a proteína. Sigma (“Alinhamento múltiplo codicioso simples”) é um programa de alinhamento com um novo algoritmo e esquema de pontuação projetado especificamente para seqüência de DNA não codificante.

Site: http://www.imsc.res.in/~rsidd/sigma/

Outros documentos:

Citação: Rahul Siddharthan, “Sigma: alinhamento múltiplo de sequências de DNA não codificantes fracamente conservadas”, BMC Bioinformatics 7: 143 ( 2006). Pubmed

 

SIGNATURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/signature/

 

STRUCTURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/structure/

 

TREEFINDER calcula árvores filogenéticas a partir de seqüências moleculares. O programa infere árvores mesmo grandes por máxima probabilidade sob uma variedade de modelos de evolução de seqüência. Ele aceita dados de nucleotídeos e aminoácidos e leva em consideração a heterogeneidade da taxa. Modelos separados podem ser assumidos para partições de dados definidas pelo usuário, taxas separadas, comprimentos de borda separados, composições de caracteres separadas. Todos os parâmetros podem ser estimados a partir dos dados. A pesquisa de árvores pode ser guiada por restrições topológicas fornecidas pelo usuário e iniciar árvores.

Web site: http://www.treefinder.de/

Outros documentos: o manual está disponível em formato pdf .

Citação: Jobb, G., A. von Haeseler e K. Strimmer. TREEFINDER: Um poderoso ambiente de análise gráfica para filogenética molecular. 2004. BMC Evolutionary Biology. Pubmed

 

TreeView 0.5.1
TreeView fornece uma maneira simples de ver o conteúdo de um arquivo de árvore de formato NEXUS, PHYLIP, Hennig86, Clustal ou outro formato. Enquanto PAUP e MacClade possuem excelentes instalações de impressão de árvores, pode haver momentos em que você só deseja ver as árvores sem ter que carregar o conjunto de dados de que foram geradas. O pacote PHYLIP contém programas de desenho de árvores que oferecem uma maior variedade de árvores que o TreeView, mas são um tanto desgastantes de usar. O próximo PAUP * para Windows não possui uma interface gráfica, portanto, o TreeView permite que você crie árvores de qualidade de publicação a partir de arquivos PAUP, diretamente ou gerando arquivos gráficos para edição por outros programas.

Web site: http://taxonomy.zoology.gla.ac.uk/rod/treeview.html

Outra documentação:

Citação: Page, RDM 1996. TREEVIEW: uma aplicação para exibir árvores filogenéticas em computadores pessoais. Aplicações informáticas nas Biociências 12: 357-358.

 

 

TOPO-1.0.0
TOPO cria uma imagem de uma proteína transmembranar.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/topo/topo.html

 

Vienna RNA 1.8.25

O Vienna RNA Package consiste em uma biblioteca de código C e vários programas autônomos para a predição e comparação de estruturas secundárias de RNA.
A predição da estrutura secundária do RNA através da minimização de energia é a função mais utilizada na embalagem. Nós fornecemos três tipos de algoritmos de programação dinâmica para a predição da estrutura: o algoritmo mínimo de energia livre de (Zuker & Stiegler 1981) que produz uma única estrutura ótima, o algoritmo de função de partição de (McCaskill 1990) que calcula as probabilidades de pares de bases no conjunto termodinâmico, e o algoritmo de dobragem sub-óptimo de (Wuchty et.al 1999) que gera todas as estruturas sub-ótimas dentro de uma determinada faixa de energia da energia ideal. Para a comparação de estrutura secundária, o pacote contém várias medidas de distância (dissimilaridades) usando o alinhamento de cordas ou a edição de árvores (Shapiro & Zhang, 1990). Finalmente, fornecemos um algoritmo para projetar seqüências com uma estrutura predefinida (dobra inversa).

Web site: http://www.tbi.univie.ac.at/RNA/

Outros documentos:

Citação: Ivo L. Hofacker, Walter Fontana, Peter F. Stadler, L. Sebastian Bonhoeffer, Manfred Tacker e Peter Schuster. Folding Rápido e Comparação de Estruturas Secundárias de RNA. Apareceu em: Monatsh.Chem. 125: 167-188 (1994).

 

 

Faça o download do DNALinux

DNALinux Virtual Desktop. Python for Bioinformatics Edition (NOVO! Jun 2009)

Instruções de instalação

  1. Baixe o arquivo torrent .
  2. Faça o download do DNALinux usando o torrent com um programa compatível com bittorrent como “Bittorrent”, Bittorrnado, Vuze ( veja aqui para obter uma lista completa )
  3. Faça o download do VMWare Free Player
  4. Baixar 7zip uncompressor
  5. Descompacte DNALinux.7z usando o 7zip e reproduza o arquivo vmk com o VMWare Player.

Download direto no RapidShare (12 partes):

Instrução para arquivos baixados do Rapidshare:

Para juntar as peças no Windows:

copiar / b dbasea * dnalinux.7z

Para juntar as peças no Linux:

gato dbasea *> dnalinux.7z

Soma de verificação MD5: f75e88f48e08161be62b70a8ef465e17

Versão antiga (não suportada):

Servidor DNALinux

Nota: A nova versão (VDE Python para Bioinformatcs) já é um servidor, portanto a edição do servidor é interrompida.

 

 

 

 

 

 

 

 

Fonte: http://www.dnalinux.com/installedsoftware.html

Hyperledger

 

Hyperledger (ou o “Projeto Hyperledger”) é um projeto colaborativo envolvendo várias indústrias, iniciado em dezembro de 2015 pela Linux Foundation,[1] seu objetivo é suportar livros razão distribuídos com base na Blockchain. O seu foco é livros razão feitos para suportar transações de indústrias globais, incluindo as principais empresas de tecnologia, financeiras e logísticas, com o objetivo de melhorar vários aspectos da performance e robustez.[2] O projeto aspira unir um número de tentativas independentes para desenvolver protocolos e padrões abertos, provendo um framework modular que suporta componentes diferentes para usuários diferentes. Isso inclui uma variedade de blockchains, cada uma com seu consenso, modelos de persistência, e serviços para identidade, controle de acesso e contratos.

Histórico

Em Dezembro de 2015, a Linux Foundation anunciou a criação do projeto Hyperledger. Os primeiros fundadores do projeto foram anunciados em Fevereiro de 2016, e mais 10 membros que compõem o conselho de administração foram anunciados em 29 de Março.[3] Em 19 de Maio, Brian Behlendorf foi apontado como diretor executivo do projeto.[4]

No inicio de 2016, o projeto começou a aceitar propostas para bases de código e outras tecnologias a serem incubadas, para potencial inclusão como componentes centrais do Hyperledger. Uma das primeiras propostas foi para uma base de código que combina trabalhos prévios feitos pela Digital Asset Holdings (Blockstream’s libconsensus) e a OpenBlockchain da IBM.[5]Posteriormente, esse projeto foi renomeado para Fabric.[6] Em maio, o livro razão distribuído da Intel (Sawtooth) também foi incubado.[7]

Membros

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

De acordo com o Whitepaper do Hyperledger [8]:

As a fledgling technology, existing blockchain implementations have fallen short of meeting the multitude of requirements inherent in the complex world of business transactions. Scalability challenges, and the lack of support for confidential and private transactions, among other limitations, make its use unworkable for many business-critical applications. […] To meet the varied demands of the modern marketplace, Hyperledger has been designed for a broad array of industry-focused use cases, thereby extending the work of the pioneers in the field by addressing the existing shortcomings.

Em outras palavras, baseado no cenário atual de requisitos da indústria, foi identificado que as implementações atuais de blockchain não são suficientes. Problemas de escalabilidade, falta de suporte para transações privadas e outras limitações são citados como os principais culpados. A proposta do Hyperledger é justamente suprir esses requisitos a partir de uma série de casos de uso. A ideia também consiste de estender trabalhos existentes com o objetivo de mitigar as suas limitações. Vale destacar que o Hyperledger tem o foco na indústria, mais especificamente nas relações B2B e B2C.[8]

Objetivos

O objetivo principal do Hyperledger é criar uma plataforma útil, fácil de usar e robusta onde qualquer individuo interessado em construir um software baseado em blockchain pode usa-lá como base. Por motivos práticos, o Hyperledger pode nunca alcançar esse ideal que cobre todos os casos possíveis, mas o objetivo do time é chegar o mais perto possível.[8]

De maneira mais tangível, o projeto também define objetivos mais específicos como: modularidade, extensibilidade, facilidade de uso, variedade de métodos criptográficos. Cada um desses objetivos contribui para a visão geral do Hyperledger. Por exemplo, a modularidade contribui para a interoperabilidade entre sistemas que, por sua vez, potencializa a flexibilidade do projeto, e aumenta a cobertura de casos. A extensibilidade também contribui para aumentar a cobertura de novos casos, já que funcionalidades novas podem ser adicionadas.[8]

A conceito da modularidade é importante porque incentiva o desenvolvimento externo. Uma empresa não relacionada pode desenvolver novos módulos e contribuir para a melhora de módulos existentes. Generalizando, deve ser possível construir uma blockchain que não usa nenhum componente central do Hyperledger, mas ainda assim, se encaixar no seu framework. A troca de componentes a fim de satisfazer requisitos específicos também é um conceito central do Hyperledger. Por exemplo, alguns casos pedem um algoritmo rápido de consenso que requer alguma confiança, enquanto outros casos podem pedir menos velocidade com mais confiança.[8]

A extensibilidade e modularidade se provam como requisito central do projeto porque é inviável prever todos os usos futuros do Hyperledger e de tecnologias blockchain de uma maneira geral. Facilitar as contribuições externas pode incentivar o envolvimento de pessoas que contribuirão e usarão o Hyperledger.[8]

Requisitos propostos

Transações privadas e contratos confidenciais

O Hyperledger pretende suportar uma variedade de ferramentas criptográficas que devem garantir a presença de confidencialidade e privacidade. Essas ferramentas não devem prejudicar as propriedades de privacidade. Alguns casos de uso requerem confidencialidade mais básicas e otimizadas para performance que não são adequadas para o uso financeiro. O objetivo é suportar tanto o caso otimizado par performance quanto os casos mais sofisticados que pedem algoritmos criptográficos mais complexos.[8]

Identidade e auditabilidade

Em adição as transações privadas e confidenciais, o conceito de identidade baseado numa infraestrutura de chave pública completa os algoritmos criptográficos provendo a confidenciabilidade do Hyperledger. Além da infraestrutura de chave pública, o Hyperledger também deve prover suporte a uma documentação compreensível e imutável sobre essas identidades – incluindo os requisitos de confidenciabilidade associada a elas. O objetivo da documentação é suportar os casos que envolvem troca de identidade e auditoria. É importante notar que sempre deverá ser respeito o contrato inicial sobre a anonimidade da identidade. Por exemplo, se é previso que certa entidade é totalmente anonima, a documentação não incluirá nada que quebre esse acordo.[8]

Interoperabilidade

Como o Hyperledger propõe a utilização de vários componentes independentes, a interoperabilidade é proposta para que a interação entre esses elementos ocorra apesar de possíveis implementações fundamentalmente diferentes. Por exemplo, é esperado que haja a cooperação entre mais de um tipo de blockchain. Dessa forma, é dito que existe interação quando informação é trocada e utilizada por esses componentes. Para prover esse caso de uso, é definido um protocolo que permite a comunicação entre 2 ou mais blockchains.[8]

Portabilidade

A portabilidade em um nível de infraestrutura garante que o projeto Hyperledger funcione da mesma maneira em ambientes computacionais heterogêneos. O valor da portabilidade é explicitado ao ressaltar que o projeto deverá rodar com base numa grande combinação de blockchains, falhar em prover a portabilidade fere um principio geral do Hyperledger. A portabilidade em um nível de arquitetura tem significado parecido com o de modularidade: significa abstrair as interfaces dos componentes centrais para que não haja acoplamento de ambientes. Por exemplo, o componente de contratos inteligentes pode ser movido para uma unidade diferente de produção sem que haja necessidade de mudança a esse componente. [8]

Arquitetura

A arquitetura geral do Hyperledger consiste de 4 categorias:

  • Identidade (Identity)
  • Política (Policy)
  • Blockchain e contratos inteligentes (Smart Contracts)

De uma forma geral, essas categorias possuem responsabilidades específicas: a identidade é responsável por identificar as entidades participantes, a policy é responsável por regular o acesso e responsabilidades dessas entidades e o blockchain provê o serviço p2p que guarda o estado do sistema. Vale destacar que essas categorias são divisões lógicas do software e não necessariamente significam serviços fisicamente separados.[8]

Serviços de identidade

O requisito deste componente é identificar os componentes participantes da rede. Esses componentes incluem organizações participantes, validadores e transactors; Objetos contidos no livro razão e componentes mais tangíveis como: redes, servidores e ambiente de execuções.[8]

Serviços de política 

Os serviços de política permitem o gerenciamento das políticas de acesso ao sistema. Algumas dessas políticas incluem o gerenciamento do registro de novos membros e o controle de suas entradas e saídas. Esse serviço também é responsável pelo níveis de privacidade e as políticas de confiabilidade, responsabilidade e consenso. [8]

Blockchain

Os serviços de blockchain consistem de 3 partes:

  • Protocolo P2P.
  • Livro razão distribuído.
  • Gerenciador de Consenso.

O protocolo P2P funciona em cima da infraestrutura atual da internet e provê as capacidades de intercomunicação do sistema. O livro razão distribuído é a parte central do sistema e tem características parecidas com a de outros sistemas de criptomoedas. Por exemplo, o livro razão é responsável por manter e processar o estado do sistema e isso também é comum a bitcoin. Outras responsabilidades do livro razão distribuído sob o contexto do Hyperledger incluem: validar transações; calcular o hash de toda a base de dados de forma eficiente após cada bloco; minimizar a quantidade de dados necessários necessários para uma participante operar.[8]

Por fim, o gerenciador de consenso provê uma abstração para que outras partes do sistema utilizem os algoritmos de consenso de forma transparente. A ideia central é facilitar o uso e ao mesmo tempo prover um sistema flexível o suficiente para que novos procedimentos de consenso também possam ser adicionados.[8]

Incubação de projetos

Como um dos objetivos do Hyperledger é agregar contribuições externas, é adotada uma política de incubação para o gerenciamento dessas contribuições. Unidades de trabalhos são chamados de Projetos, e esses Projetos possuem um ciclo de vida [9]:

  • Proposta
  • Incubação
  • Maturidade
  • Depreciado
  • Fim de vida

Metodologias de gerenciamento similares são comuns a outros projetos open source, como o eclispe,[10] apache [11] e o OSGEO.[12] Até Julho de 2016, o Hyperledger possui dois projetos em fase de incubação, o Fabric e o Sawtooth.[13]

Sawtooth

O projeto Sawtooth, consiste na implementação de uma plataforma para construir e rodar livros razões distribuídos. O seu objetivo de modularidade é alinhado ao Hyperledger e é um dos motivos pela sua incubação. Diferente do Bitcoin, a proposta do Sawtooth é oferecer flexibilidade, desde transferências internacionais até aplicações de internet das coisas.[14]

Fabric

O fabric também é um projeto de tecnologias blockchain que oferece a possibilidade de encaixar várias implementações para certas funcionalidades. A versão de preview disponível em Julho de 2016 possui as seguintes features[15]:

  • Blockchain permissiva com finalidade imediata
  • Ambientes para a execução de contratos inteligentes
  • Módulos de consenso PBFT, NOOPS e SIEVE
  • Framework de eventos que suporta eventos predefinidos e customizados
  • SDK Client e API REST Básicas e Ferramentas CLI

Nessa mesma versão, estão presentes alguns BUGs e limitações, como [15]:

  • Alto tempo de resposta depois de testes de estresse.
  • Não possui eventos para peers no SDK.
  • Atributos no TCert não estão encriptados.

Referências

  1.  «Linux Foundation Unites Industry Leaders to Advance Blockchain Technology». 17 de dezembro de 2015
  2. Ir para cima «Linux Foundation’s Hyperledger Project Announces 30 Founding Members and Code Proposals To Advance Blockchain Technology». 9 de fevereiro de 2016. Consultado em 17 de fevereiro de 2016
  3. Ir para cima «Open Source Blockchain Effort for the Enterprise Elects Leadership Positions and Gains New Investments». 29 de março de 2016
  4. Ir para cima «Founder of the Apache Software Foundation Joins Linux Foundation to Lead Hyperledger Project». 19 de maio de 2016
  5. Ir para cima «Incubating Project Proposal: Joint DAH/IBM proposal». Tamas Blummer, Christopher Ferris. 29 de março de 2016. Consultado em 21 de junho de 2016
  6. Ir para cima «hyperledger/fabric»GitHub. Consultado em 23 de junho de 2016
  7. Ir para cima «Sawtooth Lake Hyperledger Incubation Proposal». Mic Bowman, Richard Brown. 14 de abril de 2016. Consultado em 21 de junho de 2016
  8. ↑ Ir para:a b c d e f g h i j k l m n o «Hyperledger Whitepaper». Consultado em 5 de julho de 2016
  9. Ir para cima «Hyperledger Project Lifecicle». Consultado em 6 de julho de 2016
  10. Ir para cima «Eclipse Development Process 2015». Consultado em 6 de julho de 2016
  11. Ir para cima «Apache Incubator». Consultado em 6 de julho de 2016
  12. Ir para cima «OSGEO Incubation Process». Consultado em 6 de julho de 2016
  13. Ir para cima «Hyperledger github». Consultado em 6 de julho de 2016
  14. Ir para cima «Sawtooth introduction». Consultado em 6 de julho de 2016
  15. ↑ Ir para:a b «Fabric Releases». Consultado em 6 de julho de 2016

Bitcoin e Blockchain para leigos

O ativo financeiro digital mais famoso da internet é o BitcoinQue funciona em cima de uma tecnologia chamada “Blockchain”, que registra todas as transações envolvendo bitcoins, eletronicamente numa espécie de livro-razão imutável e criptografado.

Uma das característica do Bitcoin é mecanismo é que o registro dos negócios não é centralizado ou administrado por uma única instituição. O histórico das transações é armazenado em blocos que somente se encaixam se for utilizada certo tipo de assinatura digital.

E para haver a efetiva liquidação das operações, a cadeia de transações deve ser validada pelos demais participantes do mercado(mineradores, que emprestam sua força computacional para validar transações e criar novos bitcoins na rede, com isso ganham frações de bitcoins), para isso precisam confirmar a veracidade da chave pública divulgada. O desenvolvimento dessa intrincada engrenagem é atribuído a uma pessoa – ou a um grupo – que usou o pseudônimo de SatoshiNakamoto. Tecnologia criada em 2008, que seu autor até hoje permanece no anonimato.

Na prática a tecnologia do “Blockchain” implica mudança significativa na forma como a internet pode ser utilizada. Como distribuir e compartilhar informações, passa ser possível a transferência eletrônica da propriedade de ativos.

Por essa razão, a expectativa é que, no futuro próximo, será construída uma internet dos valores. Nesse novo ambiente, ao enviar um arquivo contendo determinado código, a propriedade do bem será automaticamente transferida.

Com o Blockchain já é possível imaginar diversos usos para a tecnologia, tais como contratos inteligentes onde se encerram e automaticamente, operações no mercado financeiro onde você poderá custodiar suas ações e trocá-las, transações de comércio internacional e a compra e venda de imóveis, registros de casamentos, nascimento e falecimento.

Hoje já existem 16,5 milhões de bitcoins no mercado. Por definição, o estoque máximo de bitcoins emitidos será de 21 milhões de unidades.

Nota: “Um” bitcoin é dividido em oito casas decimais (1.00000000), fracionando o seu valor, sendo assim você pode comprar frações de bitcoins, que no momento que foi escrito esse texto, a cotação atual comprando R$ 50,00 reais daria por volta de 0,00600000 bitcoins.

Os verificadores das transações, chamados no jargão do mercado de mineradores, podem criar bitcoins conforme o volume de cálculos executados, a rede dificulta a quantidade de bitcoins criados, pela quantidade de mineradores trabalhando nela e com tempo pelo seu processo deflacionário, escassez. A rede de mineradores é que garante o processamento das transações e a segurança do mercado(mineradores, são quaisquer pessoas que emprestam sua força computacional para validar e registrar as transações).

Leia também  Novo regulamento de criptomoedas da Coréia do Sul proíbe completamente Marketing Multinível

À prova de balas e transparente

Ninguém foi capaz, pelo menos por enquanto, de invadir o sistema para criar bitcoins falsos. Isso tem garantido a confiança na segurança da estrutura e atraído novos participantes.

Nas operações bancárias tradicionais, o Banco é a instituição responsável pelo controle do livro caixa das transações. E cobra altas tarifas por esse serviço, e sem contar que a qualquer momento pode “confiscar a sua poupança”, como já vimos há tempos atrás.

Por exemplo, para enviar um TED ou DOC, o Banco exige o pagamento de determinada remuneração. O mesmo acontece para manter a conta corrente ativa e emitir extratos, já o Bitcoin, você não precisa pagar taxas de custódia, manutenção, extratos, apenas paga pela sua transferência, uma taxa irrisória.

As operadoras de cartão de crédito também cobram para processar as transações entre lojistas e consumidores e também taxas de anuidade. O mesmo acontece com as bolsas de valores e de mercadorias para administrar a posição de cada investidor cobrando taxa de custódia e corretagens.

Em algumas transações os custos podem ser tão altos a ponto de inviabilizar as operações de pequeno montante, como no caso das transferências internacionais de valores financeiros, onde são inseridas novas taxas e ainda pode demorar dias para se concretizar, se concretizar… Onde pode aumentar o prazo, dependendo de finais de semanas e feriados.

Aceitação do Bitcoin no mundo

Uma das ideias do Bitcoin, portanto, é baratear os custos das transações, com valores irrisórios comparados a Bancos. A consequência pode ser o aumento no volume de negócios.

Por exemplo, um desenvolvedor de softwares no Brasil pode contratar os serviços de um programador na Ucrânia e pagar pelo trabalho por meio da transferência de bitcoins. Nessa situação o Bitcoin é usado como um meio de troca.

Considerando que a atual estrutura da internet já viabiliza a troca de arquivos sem barreiras geográficas, o uso em larga escala do bitcoin teria o efeito de estimular o comércio global de bens e serviços, com transferência de bitcoin para qualquer parte do mundo, com tempo médio de 10 minutos..

Leia também  Coreia do Sul prepara-se para taxar o uso do Bitcoin

Dado que o bitcoin possui cotação tanto em dólares quanto nas demais moedas mundiais, o programador ucraniano do exemplo poderia optar por manter parte de sua remuneração recebida do desenvolvedor brasileiro em bitcoins, como uma poupança.

Por fim, a decisão do programador ucraniano poderia ser a de gastar parte dos bitcoins na compra de produtos e serviços para serem consumidos, ou comprar produtos para o aperfeiçoamento do seu trabalho, tal como computadores e eletrônicos. A empresa americana Dell Computer, que fabrica computadores e notebooks, é um das lojas que aceitam bitcoin, na compra de seus produtos. Existe também um site brasileiro, chamado “Classificados BTC“, onde é possível comprar e vender produtos e serviços, com bitcoin.

Mesmo o Bitcoin não sendo considerado uma “moeda” (meio de troca, unidade de conta e reserva de valor; baseado no conceito econômico), pelos economistas, ainda sim é um excelente meio de troca, universalmente aceito, ainda que galgando.

O Bitcoin possui um valor especulativo. A cotação de um bitcoin saltou de pouco menos de US$ 300 em julho de 2015 para mais de US$ 2 mil em julho de 2017.

Para negociar Bitcoin, vale o alerta: como em todo investimento especulativo, é fundamental conhecer os riscos envolvidos, mas ao mesmo tempo o Bitcoin não é definido pelo preço, e sim sua tecnologia disruptiva que vamos descrever abaixo:

Bitcoin

  • 24h – Bitcoin funciona 24 horas por dia, 365 dias no ano, nunca para e as transações podem acontecer a qualquer hora do dia ou da noite, independente de finais de semanas e feriados.
  • Rápido – simples como enviar um e-mail ou sms, de um telefone móvel.
  • Descentralizado – não tem um controlador central, podemos transacionar com qualquer pessoa sem depender de um intermediador, uma rede ponto-a-ponto ou peer-to-peer, parecida com a rede do BitTorrent. BTC, também conhecido como Bitcoin, é um sistema livre, que não pode ser confiscado, como já aconteceu com a poupança nos anos 90.
  • Deflacionário – ao contrário do dinheiro emitido a esmo pelos Bancos Centrais, que geram inflação, o bitcoin é deflacionário e poderá ser criado somente 21 milhões, onde são criados em uma ordem decrescente.
  • Sistema de pagamento – O bitcoin é um ativo ao portadorvocê pode ser seu próprio Banco, transacionando e custodiando seus BTCs (a sigla de bitcoin).
  • Meio de troca – uma das maiores construtoras  do Brasil, a Tecnisa, aceita bitcoin como meio de pagamento em seus imóveis e várias pessoas no Brasil já entenderam as vantagens de aceitar Bitcoin e estão vendendo desde eletrônicos, até carros e casas de luxo, no Classificados BTC.
  • Privacidade – você pode ter milhões em Bitcoins, sem ter sua vida exposta pela FORBES, pois o seu nome não será divulgado na rede, você será identificado na rede com uma chave pública(parecida com essa: 1hlY78hOwe46VCd90oNuRX2j80se43WZ).
  • Segurança – a rede conjuntamente faz com que as regras sejam cumpridas, e acompanhada de uma resposta rápida dos seus usuários se alguém tentar fraldar o sistema, e também o custo benefício não compensa
  • Barato – custo irrisório, seja para enviar bitcoin para seu vizinho ou para o Japão, o custo é o mesmo.
  • Transparência – Bitcoin é um sistema de código aberto e as transações estão totalmente disponíveis para auditoria de qualquer pessoa, em tempo real, elas ficão registradas no Blockchain, o livro razão imutável com todas as transações da história do software Bitcoin registradas.
  • Inclusão social – metade da população brasileira não tem acesso a contas bancárias, por “N” motivos, mas o Bitcoin veio para mudar essa situação, onde quem quiser transferir dinheiro para qualquer parte do mundo, seja para se incluir no sistema financeiro ou ajudar em uma catástrofe mundial, você só precisa de um telefone móvel, acesso a internet e baixar o software do Bitcoin para transferir recursos para qualquer parte do mundo ou mesmo se incluir nele.
Com o Blockchain, Bitcoin é apenas o começo!

 

Fonte: https://guiadobitcoin.com.br/bitcoin-e-blockchain-para-leigos/

A segurança do bitcoin pela força computacional

 

A segurança no bitcoin é alcançada pela descentralização e pela força computacional. Este não é um vídeo técnico, mas sim uma visão geral do funcionamento da tecnologia.

Para fontes mais técnicas e detalhas, ver artigos abaixo.

Para saber mais:

Artigo “A grande inovação tecnológica do bitcoin Parte 1/2” http://www.infomoney.com.br/blogs/cam… Mining Bitcoin Wiki: https://en.bitcoin.it/wiki/Mining

Beginners’ Guide to Mining: https://99bitcoins.com/beginners-guid…

Bitcoin Mining Explained: https://chrispacia.wordpress.com/2013…

Everything you need to know about BTC mining: https://www.bitcoinmining.com/

How the bitcoin protocol actually works: http://www.michaelnielsen.org/ddi/how…

“Bitcoin – a Moeda na Era Digital”, livro publicado pelo Instituto Mises Brasil em 2014. http://www.mises.org.br/Ebook.aspx?id=99

Blog “Moeda na Era Digital” no portal InfoMoney http://www.infomoney.com.br/blogs/cam…

Está pensando em usar ou comprar bitcoin? Leia aqui antes: http://www.infomoney.com.br/blogs/cam…

Apoie este canal! Bitcoin: 1C6qa2DctPUcyAasDkgdBTJjhgpXaVjcUE

Contatos: Email: ulrich@mises.org.br

Facebook: https://www.facebook.com/fernando.ulrich

Twitter: https://twitter.com/fernandoulrich