Criar um programa no Visual Studio que será utilizado como serviço no Windows

Olá MY FRIENDS!

Hoje vai uma dica para aqueles que fizeram seu aplicativo no Visual Studio e querem transformá-lo num serviço do sistema operacional.  Pois bem, vamos lá.

fonte: https://mastigado.wordpress.com

First!

Criando um projeto de Serviço do Windows

Criaremos no Visual Studio um projeto do tipo Windows Service.

Criando a classe Windows Service

Após criado o projeto para serviço do Windows iremos configurá-lo. Dê dois cliques em cima da classe Service1 criada no menu de projetos e ao abrir no lado direito clique com o botão direito do mouse para que seja exibido o seu código.

 

Visualizando a classe padrão criada

Após feito o procedimento podemos exibir o código que virá como na forma abaixo e adiante o alteraremos.


namespace WindowsService
{
   public partial class Service1 : ServiceBase
   {
      public Service1()
      {
         InitializeComponent();
      }

      protected override void OnStart(string[] args)
      {
      }

      protected override void OnStop()
      {
      }
   }
}

4º – Dentro do código acima faremos a seguintes alterações:

Colocaremos uma Thread para executar o serviço e diremos a ela qual será o método que ela irá chamar.  Contudo deixo aqui uma definição sobre Thread (que peguei no site do Canal Tech) para aqueles que apenas darão Ctrl + C e Ctrl + V nesse código.

Thread é um pequeno programa que trabalha como um subsistema, sendo uma forma de um processo se autodividir em duas ou mais tarefas. É o termo em inglês para Linha ou Encadeamento de Execução. Essas tarefas múltiplas podem ser executadas simultaneamente para rodar mais rápido do que um programa em um único bloco ou praticamente juntas, mas que são tão rápidas que parecem estar trabalhando em conjunto ao mesmo tempo.

Ou seja a thread é um processo, um outro programa que você pode abrir a partir da execução do seu programa principal. Esse programa  principal é chamado de thread pai e a threads que se originam dele são as threads filhas. Essa relação de pai e filha sempre se dão quando uma thread origina outra e não necessariamente apenas quando se originam do programa principal. Breve em outro explicarei com maior riqueza de detalhes sobre esse tema porque existem muitas situações que acontecem em torno desse processo, portanto continuemos.

Uma das coisas bem legais de abrir uma thread em seu programa é dizer para ela que você quer executar apenas parte de seu código. Portanto devemos construir a seguir:

  • Um método que irá executar o serviço;
  • Declarar a nossa thread inicial dizendo a ela que executará o método que criamos;
  • Criar outro método gravará um texto em um arquivo em nosso hard disc;
  • Preencher os métodos OnStart e OnStop;
namespace WindowsService
{
   public partial class Service1 : ServiceBase
   {
      private static Thread thServico = new Thread(Servico);

      public Service1()
      {
         InitializeComponent();
      }

      private static void Servico()
      {
         for(;;)
         {
            GravarTextoEmArquivo("SERVIÇO SENDO EXECUTADO AS " + DateTime.Now.ToString() + ".");

            // Coloca a Thread para dormir por uma hora
            Thread.Sleep(3600000); //1 hora
         }
      }

      protected override void OnStart(string[] args)
      {
         try
         {
            AbrirArquivo("SERVIÇO INICIALIZADO AS " + DateTime.Now.ToString() + ".");
            thServico.Start();
         }
         catch(Exception e)
         {
            Console.WriteLine(e.Message);
         }
      }

      protected override void OnStop()
      {
         try
         {
            AbrirArquivo("SERVIÇO PARALISADO AS " + DateTime.Now.ToString() + ".");
            thServico.Abort();
         }
         catch(Exception e)
         {
            Console.WriteLine(e.Message);
         }
      }

      public static void GravarTextoEmArquivo(string texto)
      {
         StreamWriter vWriter = new StreamWriter(@"C:\Log\LogServico.log", true);
         vWriter.WriteLine(texto);

         vWriter.Flush();
         vWriter.Close();
      }
   }
}

Destrinchando:

No trecho abaixo é onde declaramos a nossa Thread e já em seu construtor dizemos qual método ela irá executar.


   private static Thread thServico = new Thread(Servico);

Aqui abaixo está o método que executamos o principal conteúdo do nosso serviço.  Gravamos em um arquivo texto a data atual e em seguida colocamos nossa Thread para dormir durante 1 hora.


private static void Servico()
{
   for(;;)
   {
      GravarTextoEmArquivo("SERVIÇO SENDO EXECUTADO AS " + DateTime.Now.ToString() + ".");

      // Coloca a Thread para dormir por uma hora
      Thread.Sleep(3600000); //1 hora
   }
}

Logo abaixo temos os métodos que vem por padrão na criação da classe e que servirão para o serviço do Windows executar quando paralisado ou iniciado.

protected override void OnStart(string[] args)
{
   try
   {
      AbrirArquivo("SERVIÇO INICIALIZADO AS " + DateTime.Now.ToString() + ".");
      thServico.Start();
   }
   catch(Exception e)
   {
      Console.WriteLine(e.Message);
   }
}

protected override void OnStop()
{
   try
   {
      AbrirArquivo("SERVIÇO PARALISADO AS " + DateTime.Now.ToString() + ".");
      thServico.Abort();
   }
   catch(Exception e)
   {
      Console.WriteLine(e.Message);
   }
}

E por fim o nosso método que grava em arquivo o que está acontecendo em nossa Thread.

public static void GravarTextoEmArquivo(string texto)
{
   StreamWriter vWriter = new StreamWriter(@"C:\Log\LogServico.log", true);
   vWriter.WriteLine(texto);

   vWriter.Flush();
   vWriter.Close();
}

Adicionando Instalador do Serviço

Agora iremos adicionar o Instalador do Serviço. Dê dois cliques na classe que você criou que contém a rotina do serviço que será instalado e quando clicar com o botão direito, no menu que se abrirá adicione um instalador em Adicionar Instalador.

Classe ProjectInstaller

Bem, para ver o código do instalador você pode fazer o mesmo procedimento que fizemos na classe anterior, clique duas vezes em cima do arquivo, depois com o botão direito no lado esquerdo da tela clique em Exibir Código e algo como o código abaixo deverá aparecer, mas neste código não iremos alterar nada, então fica aí só para você matar sua curiosidade mesmo.


[RunInstaller(true)]
public partial class ProjectInstaller : System.Configuration.Install.Installer
{
   public ProjectInstaller()
   {
      InitializeComponent();
   }
}

Caso precisem precisem vocês podem consultar o Gist do Blog Mastigado e consultar o código da classe Service1.cs no link https://gist.github.com/blogmastigado.

Repare que ao abrirmos o arquivo Project Installer ao selecionarmos a caixa de texto à direita e pressionarmos a tecla F4 podemos alterar a descrição e título do Serviço que será instalado no Windows.

Classe Padrão Program.cs

Vale lembrar que quando criamos um projeto do tipo Serviço também foi gerado um arquivo chamado Program.cs que contém o código que inicializa nossa classe Service1, mas que não há necessidade de o alterarmos. O código está abaixo.


namespace WindowsService
{
   static class Program
   {
      ///
      /// Ponto de entrada principal para o aplicativo.
      /// 

      static void Main()
      {
         ServiceBase[] ServicesToRun;
         ServicesToRun = new ServiceBase[]
         {
            new Service1()
         };
         ServiceBase.Run(ServicesToRun);
      }
   }
}

Publicar o executável do serviço

Para publicarmos nosso app precisamos compilar o projeto e depois pegar tudo que está que está contido no diretório Release do projeto e colocarmos no local onde deverá ser instalado, ou se preferirmos, após a compilação podemos publicar os arquivos gerados (clicando com o botão direito em cima do projeto e seguida clicando em Publicar) em um local de preferência.

Instalar ou Desinstalar o serviço no Windows

Para Instalar ou Desinstalar um serviço no Windows é preciso executar o prompt de comando do Windows (cmd.exe), preferencialmente como administrador e seguir até o diretório C:\Windows\Microsoft.NET\Framework64\v4.0.30319. Faço uma observação aqui sobre o fato de eu ter usado o Net Framework versão 4 e ter preferido instalar utilizando o framework de versão 64 bit, portanto saiba que isso é apenas umas preferência pessoal podendo você fazer usar 32 ou 64 ou outra versão de Net Framework.

Dentro do diretório do instalador do serviço execute uma aplicação de nome InstallUtil.exe como na figura abaixo.

Assim que instalar deverá aparecer uma tela lhe pedindo seu login e senha. E após digitar corretamente as informações o serviço estará instalado.

Observação 1: Se estiver no seu PC pessoal utilize no campo Username o termo NomeDoSeuPC\NomeDoSeuUsuario e se estiver numa rede com domínio NomeDoUsuario@NomeDoSeuDominio.

A sintaxe para instalar/criar um serviço é basicamente essa:


InstallUtil seuprojeto.exe

E para desinstalá-lo é essa:


InstallUtil /u seuprojeto.exe

Lembrando que pode ser preciso informar o caminho completo de onde o arquivo executável do seu projeto está.

DEBUG

Para ser utilizado o debug em um projeto do tipo Serviço é preciso seguir outro caminho, pois o debug comum que utilizamos na maioria das vezes não funciona neste tipo de projeto. Porém há maneira bem simples disso funcionar normalmente.

Primeiro você precisará instalar o serviço em sua máquina local de preferência, pois é lá onde você está fazendo programando seu código no Visual Studio.

E por fim você precisará colocar o trecho abaixo em seu método OnStart. Aí quando o serviço for publicado (em modo debug) e executado, automaticamente os breakpoints de seu código começarão a funcionar normalmente.


// Para habilitar o debug
#if DEBUG
Debugger.Launch();
#endif

Seu método OnStart deverá ficar escrito dessa maneira:

protected override void OnStart(string[] args)
{
    // Para habilitar o debug
    #if DEBUG
	Debugger.Launch();
    #endif

    try
    {
        AbrirArquivo("SERVIÇO INICIALIZADO AS " + DateTime.Now.ToString() + ".");         
        thServico.Start();
    }
    catch(Exception e)
    {
        Console.WriteLine(e.Message);
    }
}


Observação 2
: Para poder “debugar” seu código junto com todos os outros que participam deste projeto Windows Service você deve sempre deixar seu Visual Studio executando como Administrador, pois assim ele não te obriga a abrir uma nova instância contendo apenas o projeto Windows Service quando iniciar a execução do serviço no Windows.

Pronto! Tá aí mastigado!

fonte: https://mastigado.wordpress.com

fonte: https://docs.microsoft.com/en-us/dotnet/framework/windows-services/how-to-debug-windows-service-applications

fonte: https://docs.microsoft.com/pt-br/dotnet/framework/windows-services/how-to-install-and-uninstall-services

fonte: https://canaltech.com.br/produtos/o-que-e-thread/

Anúncios

JSON – Trabalhando em Java no Android e em C# com Asp Net MVC 5 e Web API

Caríssimos, com vão?

Pois bem. Estou aqui hoje para deixar uma dica daquelas que acho muito importante que é saber trabalhar com arrays JSON porque já dei cabeçadas com isso e volta e meia esqueço de tudo. E aí posso dizer que se você não tem um blog maravilhoso, organizado e mastigadinho como esse, a vida não seria tão boa as vezes.

fonte: http://matigado.wordpress.com

Então vamos lá? Aproveitaremos enquanto o conhecimento ainda está quentinho aqui dentro da caixola pra espalhar em códigos porque senão esqueço. Let’s go Bob!

Deixarei escritas aqui algumas definições e cenários para o caso de você identificar alguma situação parecida e saber resolver. Por hora deixarei apenas códigos sobre C# e Java, mas talvez num futuro poderei incrementar algo em PHP.

Linguagem C#

Para enviar dados JSON a partir de uma simples classe em C# para um servidor Asp Net Web API

No exemplo a seguir utilizo uma classe chamada Item que possui código e descrição como atributos. Não que isso seja importante e relevante para o caso, mas para que o leitor não fique em dúvida ilustrei abaixo como seria essa classe.


public class Item
{
    public int codigo { set; get; }
    public string  descricao { set; get; }
}

E no exemplo abaixo envio uma lista de objetos em C# para um servidor Asp Net Web API utilizando a classe WebClient contida no pacote System.Net do C#.


public string EnviarUmaListaDeObjetosEmJSONParaUmServidor(List<Item> listaitens, string url_servidor, string url_metodo)
{
   // Insiro a url raiz do servidor
   var client = new RestClient(url_servidor);

   // Defino qual será o método utilizado na requisição
   var request = new RestRequest(Method.POST);  

   // Digo qual será o formato dos dados enviados
   request.RequestFormat = DataFormat.Json;

   // Digo qual é a URL da API
   request.Resource = url_metodo;

   // Adiciono o objeto que quero transformar em JSON
   request.AddBody(listaitens);

   // Envia a requisição e espera a resposta
   IRestResponse response = client.Execute(request);
 
   return response.Content;
}

Agora, deixarei aqui uma observação para caso você precise enviar um objeto e não uma lista de objetos. Veja isso:


public string EnviarUmObjetoEmJSONParaUmServidor(Item item, string url)
{

    string json = Newtonsoft.Json.JsonConvert.SerializeObject(new
    {
       item
     });
}

Percebeu que a informação significante foi apenas a alteração da linha deste método e o anterior? Quero dizer, percebeu que neste método temos bem menos trabalho para converter algo em objeto JSON? Porque para um objeto ser convertido para uma string JSON ou um objeto JSON (JSON Object) basta apenas eu utilizar a biblioteca da Newtonsoft que você consegue utilizando o gerenciador de pacotes Nuget do C#. Quando transformamos um objeto de alguma linguagem para um objeto JSON chamamos esse processo de serialização, que na prática é a conversação de um objeto e seus atributos de forma literal para uma string. Mamão com açúcar não?

Para você receber uma string JSON num método Web API do C#

Caríssimos, tenho um amigo que não gosta da forma como trabalho os dados JSON utilizando Web API, pois segundo ele estou “comendo bola” porque não preciso mapear objetos como farei abaixo, mas veja bem, o método que descrevo aqui é apenas um método dentre tantos outros que você pode trabalhar, pois para quem trabalhava com Asp Net MVC 5 e estava acostumado a trabalhar com um retorno do tipo Action Result e o recebimento de string JSON que já era mapeado automaticamente para uma lista de objetos é assim que me sinto confortável em trabalhar, portanto não pergunte como o ASP Net MVC fazia isso, pois eu só usufruia. Mas vamos lá, mostrarei aqui algumas situações de como receber e manipular o objeto JSON recebido em um método POST numa API controller do Asp Net.

1º Cenário: Envio uma lista de itens utilizando o método descrito no começo do post e quero receber num método POST numa API controller e depois retornar uma resposta para o método que enviou a informação.

Imagine que eu tenha uma lista de objetos da classe Item e queira transformá-la em um objeto JSON com o método abaixo.

string json = Newtonsoft.Json.JsonConvert.SerializeObject(new { listadeitens });

Após ter utilizando o comando acima o conteúdo de nossa variável json será este logo abaixo.

{
   "listadeitens":[
      {
         "codigo": 12,
         "descricao":"cadeira"
      },
      {
         "codigo": 13,
         "descricao":"geladeira"
      }
    ]
}

Repare que aí dentro dessa lista existem 2 registros e que agora estão em formato de objeto JSON. Sabendo disso iremos utilizar o método que está logo no começo do post para enviarmos a string JSON ao método abaixo e em seguida o transformar-mos novamente numa lista de objetos Item, que deu origem a esta string JSON.


// POST api/<controller>
public string Post(JObject minhalistadeitens)
{
    JArray jsonArray = (JArray)minhalistadeitens["listadeitens"];

    List novalistadeitens = JsonConvert.DeserializeObject<List>(jsonArray.ToString());

    return "ok";
}

Repare bem o método acima e observe que tivemos de utilizar a linha abaixo.


JArray jsonArray = (JArray)minhalistadeitens["listadeitens"];

A utilizamos porque na assinatura do método esperamos por um objeto JSON (JObject) e no caso acima recebemos um objetos que contém uma lista de nome listadeitens, portanto precisamos antes identificar onde estava essa lista dentro desse objeto para só assim podermos fazer a conversão desse array JSON para uma lista de objetos do tipo Item. Dessa forma:


List novalistadeitens = JsonConvert.DeserializeObject<List>(jsonArray.ToString());

Isso quer dizer que após identificada o array de objetos JSON podemos “deserializá-lo”, ou seja, transformar de volta um objeto JSON para um objeto natural da linguagem.

2º Cenário: Envio uma lista de itens utilizando o método descrito no começo do post e quero receber por um método POST numa API controller e depois retornar uma resposta para o método que enviou a informação, MAS com um objeto JSON um pouquinho diferente.

Se você estiver dando uma pesquisa na net (como fiz muito antes de escrever esse post) verá que a maioria das pessoas não trabalhar com a lista de objetos JSON da mesma forma como escrevi no 1º cenário e isso pode gerar algum tipo de confusão em sua mente e por isso deixarei aqui também uma segunda maneira que você pode receber esta string JSON.

Imagine o objeto JSON anterior escrito dessa forma:


[
   {
     "codigo": 12,
     "descricao": "cadeira"
   },
   {
     "codigo": 13,
     "descricao": "geladeira"
   }
]

Consegue perceber que no caso assim existe apenas uma string JSON que contém apenas um array JSON que contém objetos JSON? Conseguiu percebeu que não existe mais (nesse caso) um objeto JSON que contém um array JSON? Portanto nesse caso devemos omitir a parte onde faríamos essa busca pelo array JSON como feito anteriormente.


// POST api/<controller>
public string Post(JObject minhalistadeitens)
{
    List novalistadeitens = JsonConvert.DeserializeObject<List>(minhalistadeitens).ToString());
    return "ok";
}

3º Cenário: Envio uma lista de itens utilizando o método descrito no começo do post e quero receber por um método POST numa API controller e depois retornar uma resposta para o método que enviou a informação, MAS gostaria de manipular a string JSON que recebo sem ter de mapeá-la para uma lista de objetos C#. Farei isso apenas por um capricho besta.

Iremos utilizar novamente aquele objeto JSON que utilizamos no inicio, aquele que contém uma lista de objetos dentro dele. Esse aqui:


{
    "listadeitens":[
     {
        "codigo": 12,
        "descricao":"cadeira"
     },
     {
        "codigo": 13,
        "descricao":"geladeira"
     }
  ]
}

No método abaixo não só iremos receber essa lista de itens como também iremos percorrê-la dentro do C#.

 

// POST api/<controller> 
public string Post(JObject minhalistadeitens)
{
    JArray jsonArray = (JArray)minhalistadeitens["listadeitens"]; 

    foreach (JObject obj in jsonArray.Children())
    {
	foreach (JProperty singleProp in obj.Properties())
	{
		string nome = singleProp.Name;
		string valor = singleProp.Value.ToString();
	}
    }
    return "ok";
}

Repare que após identificado o array JSON (JArray) podemos percorrê-la e acessar os objetos JSON que a compõe, que nada mais são objetos serializados, ou seja, em formato de string, mas que contém atributos acessíveis como o nome do atributo (nome) e seu valor (valor).

Portanto se quiséssemos converter (deserializar) cada objeto JSON para um objeto dentro do loop para um objeto C# também poderíamos.


foreach (JObject obj in jsonArray.Children())
{
    Item item = JsonConvert.DeserializeObject(obj.ToString());
}

Compreende? Não é tão difícil entender como percorrer um array JSON, não?

4º Cenário: Envio uma lista de itens utilizando o método descrito no começo do post, quero receber por um método POST numa API controller e depois retornar uma resposta para o método que enviou a informação também em forma de um array de objetos JSON.

Para retornar um objeto JSON contendo uma lista usando Web API eu crio uma classe de nome resultado, que possui um atributo chamado mensagem e outro que é uma lista de objetos.


public class Resultado
{
    public string mensagem { set; get; }
    public List listaretorno { set; get; }
}

Em seguida recebemos a minha lista de itens (do tipo Item), identificamos a lista JSON contida nela, convertemos (deserializamos) convertemos novamente para List<Item> novalistadeitens e em seguida a colocamos novamente esta lista dentro do atributo listaretorno do objeto do tipo Resultado (que modelamos na classe acima).


// POST api/<controller>
public Resposta Post(JObject minhalistadeitens)
{
    JArray jsonArray = (JArray)minhalistadeitens["listadeitens"];

    List novalistadeitens = JsonConvert.DeserializeObject<List>(jsonArray.ToString());

    Resultado resultado = new Resultado();

    resultado.mensagem = "Dados Obtidos com Sucesso";
    resultado.listaretorno = novalistadeitens ;

    return resultado;
}

E abaixo está o código que recebe o retorno do método e deserializando o resultado recebido da url Web API para dentro de um objeto do tipo Resultado.


List listadeitens = ObterTodosOsItens();

string resultadojson = "";
string url = "http://localhost:48545"

Resultado resultado = new Resultado();
List listaitem = new List();

try
{
   resultadojson = EnviarUmaListaDeObjetosEmJSONParaUmServidor(listadeitens, url)
}
catch (WebException ex)
{
    e.ToString();
    resultadojson = null;
}

// Se resultado recebido for diferente de null, prossegue
if (resultadojson != null)
{
// Deserializa o objeto vindo do Servidor
    resultado = JsonConvert.DeserializeObject(resultadojson);
    listaitem  = resultadojson.listaretorno;
}

5º Cenário: Envio uma lista de itens utilizando o método descrito no começo do post, quero receber por um método POST num controle Asp Net MVC 5 e depois retornar uma resposta para o método que enviou a informação também em forma de um array de objetos JSON.

Observe que no Asp Net MVC 5 as coisas são muito mais fáceis, pois eu não tenho que fazer nenhum tipo de conversão, basta eu receber a lista na minha assinatura e acabou. Repare bem o código até o final.

[HttpPost]
public ActionResult Add(List<Item> listaitem)
{
   JsonResult jsonResult;
   List<Item> listaitemretorno = new List<Item>();

   // Verifica se o registro é inválido e se sim, retorna com erro.
   if (listaitem == null)
   {
      jsonResult = Json(new
      {
         lista = null
      }, JsonRequestBehavior.AllowGet);

      jsonResult.MaxJsonLength = int.MaxValue;
      return jsonResult;
   }
   else
   {
      foreach (Item it in listaitem)
      {
         Item item = new Item();

         item.codigo = it.codigo
         item.descricao = it.descricao;

         listaitemretorno.Add(item);
      }

      jsonResult = Json(new
      {
         lista = listaitemretorno
      }, JsonRequestBehavior.AllowGet);
   }

   jsonResult.MaxJsonLength = int.MaxValue;
   return jsonResult;
}

Veja que no final eu inicializo um novo objeto Json, crio uma variável chamada de lista lá dentro e digo que ela recebe minha variável listaretorno, daí ele já envia de volta a lista de itens sem precisar fazer absolutamente nada mais.

Pronto né? Acho que para o C# não tenho mais como mastigar isso. Se não entenderam postem nos comentários.

Linguagem Java

Bem e se fossemos mapear um objeto JSON em Java? Imagine um objeto JSON vindo direto do Android numa lista. Seria algo dessa forma:


public List<Item> ConverterDadoJsonParaLista(DadosRecepcao dadosRecepcao) {

      List<Item> novalistadeitens = new ArrayList<Item>();

      try {

      // O objeto Json recebe o objeto Json vindo do servidor
      JSONObject jsonObject = new JSONObject(dadosRecepcao.getItens());
      JSONArray jsonArray = jsonObject.getJSONArray("listadeitens");

      // Percorre o array Json
      for (int i = 0; i < jsonArray.length(); i++) {

      // Declara um novo objeto do tipo Item para armazenar os dados vindos do servidor
      Item item = new Item();

      // O objeto recebe os campos de cada objeto Json contido no array Json
      item.setCodigo(jsonArray.getJSONObject(i).getInt("codigo"));
      item.setDescricao(jsonArray.getJSONObject(i).getString("descricao"));

      // Insere o registro na lista na nova lista de itens
      novalistadeitens.add(item);
    }
  }catch (Exception e){
     e.printStackTrace();
 }

 return novalistadeitens;
}

Olha pra cima a gente percebe o quanto a Microsoft “chupou” o Java, porque o código é praticamente igual. Não tem diferença né? Alguém alguma dúvida? Tá mastigado demais isso my friends.

Alguns bons exemplos de como receber e manipular arrays Json utilizando C#

Cenário 1: Capturando valores Json e acessando seus objetos e arrays.


string json = @"{
    'channel': {
    'title': 'James Newton-King',
    'link': 'http://james.newtonking.com',
    'description': 'James Newton-King\'s blog.',
    'item': [
        {
          'title': 'Json.NET 1.3 + New license + Now on CodePlex',
          'description': 'Annoucing the release of Json.NET 1.3, the MIT license and the source on CodePlex',
          'link': 'http://james.newtonking.com/projects/json-net.aspx',
          'categories': [
             'Json.NET',
             'CodePlex'
          ]
        },
        {
           'title': 'LINQ to JSON beta',
           'description': 'Annoucing LINQ to JSON',
           'link': 'http://james.newtonking.com/projects/json-net.aspx',
           'categories': [
           'Json.NET',
           'LINQ'
          ]
        }
    ]
  }
}";

JObject rss = JObject.Parse(json);

string rssTitle = (string)rss["channel"]["title"];
// James Newton-King

string itemTitle = (string)rss["channel"]["item"][0]["title"];
// Json.NET 1.3 + New license + Now on CodePlex

JArray categories = (JArray)rss["channel"]["item"][0]["categories"];
// ["Json.NET", "CodePlex"]

IList<string> categoriesText = categories.Select(c => (string)c).ToList();
// Json.NET
// CodePlex

Cenário 2: Utlizando Linq para ordenar dados Json.

var postTitles =
   from p in rss["channel"]["item"]
   select (string)p["title"];

foreach (var item in postTitles)
{
   Console.WriteLine(item);
}

//LINQ to JSON beta
//Json.NET 1.3 + New license + Now on CodePlex

var categories =
   from c in rss["channel"]["item"].SelectMany(i => i["categories"]).Values<string>()
   group c by c
   into g
   orderby g.Count() descending
   select new { Category = g.Key, Count = g.Count() };

foreach (var c in categories)
{
   Console.WriteLine(c.Category + " - Count: " + c.Count);
}

//Json.NET - Count: 2
//LINQ - Count: 1
//CodePlex - Count: 1

Cenário 3: Deserializando usando Linq Objects.


string jsonText = @"{
   'short': {
      'original': 'http://www.foo.com/',
      'short': 'krehqk',
      'error': {
         'code': 0,
         'msg': 'No action taken'
      }
   }
}";

JObject json = JObject.Parse(jsonText);

Shortie shortie = new Shortie
{
   Original = (string)json["short"]["original"],
   Short = (string)json["short"]["short"],
   Error = new ShortieException
   {
      Code = (int)json["short"]["error"]["code"],
      ErrorMessage = (string)json["short"]["error"]["msg"]
   }
};

Console.WriteLine(shortie.Original);
// http://www.foo.com/

Console.WriteLine(shortie.Error.ErrorMessage);
// No action taken

Bem pessoal, coloquei alguns links no rodapé e espero que este conteúdo sirva para consulta para quem precisar. Tá aí então, mastigado.

fonte: http://matigado.wordpress.com

fonte: https://www.newtonsoft.com/json/help/html/QueryingLINQtoJSON.htm

fonte: https://www.newtonsoft.com/json/help/html/ParseJsonArray.htm

fonte: https://stackoverflow.com/questions/45730022/json-post-works-in-postman-but-not-in-c-sharp

Substituir/Remover Acentos e Caracteres Especiais em C#

Caríssimos como vão? Espero que bem. Sempre bem!

fonte: http://matigado.wordpress.com

Recentemente precisando de uma ajuda para remover caracteres especiais de um sistema encontrei alguns métodos prontos na net e deixarei aqui a junção que fiz.

Minha problemática estava em migrar informações para um sistema que só recebe valores que estejam em caixa alta (letras maiúsculas), sem acentos ou caracteres especiais. Daí navegando encontrei um método que faz a substituição dos caracteres especiais mais comuns de vermos por aí por seu equivalente sem acentos e alguns outros. Por isso é bom deixar claro que nem todos os que você procura estarão aqui, mas é provável que isso aqui te ajude (como me ajudou).

Segue o método de substituição de caracteres:


public string ObterStringSemAcentosECaracteresEspeciais(string str)
{
   /** Troca os caracteres acentuados por não acentuados **/
   string[] acentos = new string[] { "ç", "Ç", "á", "é", "í", "ó", "ú", "ý", "Á", "É", "Í", "Ó", "Ú", "Ý", "à", "è", "ì", "ò", "ù", "À", "È", "Ì", "Ò", "Ù", "ã", "õ", "ñ", "ä", "ë", "ï", "ö", "ü", "ÿ", "Ä", "Ë", "Ï", "Ö", "Ü", "Ã", "Õ", "Ñ", "â", "ê", "î", "ô", "û", "Â", "Ê", "Î", "Ô", "Û" };
   string[] semAcento = new string[] { "c", "C", "a", "e", "i", "o", "u", "y", "A", "E", "I", "O", "U", "Y", "a", "e", "i", "o", "u", "A", "E", "I", "O", "U", "a", "o", "n", "a", "e", "i", "o", "u", "y", "A", "E", "I", "O", "U", "A", "O", "N", "a", "e", "i", "o", "u", "A", "E", "I", "O", "U" };

   for (int i = 0; i < acentos.Length; i++)
   {
      str = str.Replace(acentos[i], semAcento[i]);
   }
   /** Troca os caracteres especiais da string por "" **/
   string[] caracteresEspeciais = { "\\.", ",", "-", ":", "\\(", "\\)", "ª", "\\|", "\\\\", "°" };

   for (int i = 0; i < caracteresEspeciais.Length; i++)
   {
      str = str.Replace(caracteresEspeciais[i], "");
   }

   /** Troca os espaços no início por "" **/
   str = str.Replace("^\\s+", "");
   /** Troca os espaços no início por "" **/
   str = str.Replace("\\s+$", "");
   /** Troca os espaços duplicados, tabulações e etc por " " **/
   str = str.Replace("\\s+", " ");
   return str;
}

Em seguida criei outro método para fazer a chamada do mesmo:


public String TratarTermoComCaracteresEspeciais(String termo)
{
   String termotratado = "";

   // Recebo o termo digitado com o tratamento de substituição de caracteres
   termotratado = ObterStringSemAcentosECaracteresEspeciais(termo);

   // Recebo o termo já tratado, mas agora com apenas os caracteres
   // de determinado intervalo
   termotratado = Regex.Replace(termotratado, @"[^a-zA-Z0-9:,]+", "");

   // Por fim recebo termo tratado com todos os caracteres em caixa alta
   termotratado = termotratado.ToUpperInvariant();

   return termotratado;
}

Reparem que no método acima primeiro recebo original, depois faço a substituição dos caracteres, em seguida utilizo uma expressão que retorna dessa pré seleção apenas os caracteres de a a z (minúsculos), A a Z(maiúsculos) e de 0 a 9. E por fim recebo o termo tratado em caixa alta (com as letras todas em maiúsculo).

fonte: http://matigado.wordpress.com

fonte: https://www.c-sharpcorner.com/blogs/replace-special-characters-from-string-using-regex1

fonte: https://desenvolvimentonet.wordpress.com/2013/07/28/leitura-de-arquivos-csv-em-c/

Descritores de arquivo e ponteiros para os arquivos

file_decriptor

Olá pessoal!

Neste post apenas replico uma informação que contém a definição de descritor de arquivos.  Este post será parte de outro post sobre Socket que está sendo elaborado.

Foi visto que o nó de indexação de um arquivo é a estrutura de identificação do arquivo dentro de um sistema. Quando um processo quiser manipular um arquivo, ele vai simplesmente utilizar um inteiro chamado descritor de arquivo. A associação desse descritor ao nó de indexação deste arquivo se faz durante a chamada da primitiva open() (ver 1.5.4), com o descritor tornando-se então o nome local de acesso desse arquivo no processo. Cada processo UNIX dispõe de 20 descritores de arquivo, numerados de 0 a 19. Por convenção, os três primeiros são sempre abertos no início da vida de um processo:

  • O descritor de arquivo 0 é a entrada padrão (geralmente o teclado);
  • O descritor de arquivo 1 é associado a saída padrão (normalmente a tela);
  • O descritor de arquivo 2 é a saída de erro padrão (normalmente a tela).

Os outros 17 descritores estão disponíveis para os arquivos. Esta noção de descritor de arquivo é usada para a interface de Entrada/Saída de baixo nível, especialmente com as primitivas open(), write(), etc. Por outro lado, quando as primitivas da biblioteca padrão de entrada/saída são usadas, os arquivos são encontrados através dos ponteiros para os objetos do tipo FILE (tipo definido dentro da <stdio.h>).

Existem três ponteiros definidos neste caso:

  • stdin que aponta para o buffer da saída padrão (geralmente o teclado);
  • stdout que aponta para o buffer da saída padrão (normalmente a tela);
  • stderr que aponta para o buffer da saída de erro padrão (normalmente a tela).

fonte: https://www.dca.ufrn.br/~adelardo/cursos/DCA409/node17.html

Java (Maven) – Erros Inesperados

Olá pessoal, boa noite.

Hoje vou deixar uma resolução básica para um daqueles erros que acontecem no Maven quando você está construindo suas dependências no Netbeans.

fonte: https://mastigado.wordpress.com

Se ao mandar executar o seu programa Java pelo Netbeans surgem algumas mensagens do tipo:

Getting 'java.lang.UnsatisfiedLinkError': no lwjgl in java.library.path

Ou

Failed to execute goal org.codehaus.mojo:exec-maven-plugin:1.2.1:exec

Sugiro a você conferir as configurações de seu projeto, pois no meu caso os arquivos da library de outro projeto que estava tentando copiar se localizava numa pasta chama native dentro do diretório raiz de meu projeto. Para fazer isso clique com o botão direito em cima do seu projeto Netbeans e siga em Propriedades. Após a janela que se abrirá vá até Construir > Executar e adicione a informação de onde está a sua classe principal. Em Opções de VM adicione a seguinte linha:

-Djava.library.path=.\native\

Confira com a imagem abaixo e mande executar novamente.

config_path_maven

fonte: https://mastigado.wordpress.com

Integrando o GitLab no Active Directory (LDAP)

gitlab

Olá pessoal, bom dia (bom dia num blog que pode ser lido em qualquer hora, francamente, tsc…).

Hoje vou deixar uma dica para quem quer integrar a ferramenta GitLab no Active Directory.

fonte: http://matigado.wordpress.com

Para quem não conhece o GitLab, deixarei uma breve citação sobre o mesmo:

O GitLab compete com várias outras plataformas de gerenciamento de código para equipes de desenvolvimento – como o GitHub e Atlassian – mas atraiu investidores devido à sua torção open source no repositório de código e no modelo de ferramenta de colaboração, que permite aos usuários adaptar a plataforma para melhor atender às suas necessidades.

O texto acima também quer dizer que você pode baixar a ferramenta e instalar na sua empresa tendo uma espécie de GitHub lá dentro, mas sua instalação não será abordada aqui porque depende de várias dependências online e que do meu ponto de vista podem variar, portanto para ter acesso ao passo da instalação do GitLab localmente aconselho procurar no próprio site do GitLab (lembrando que instalei no Linux Debian 8).

Definições para o arquivo de configuração

Para a nossa configuração junto ao Active Directory vamos supor que tenhamos um servidor com as seguintes informações:

  • Nome do servidor do AD: meu_servidor_do_ad
  • Nome do domínio: dominio.central
  • Local onde está localizado o usuário administrador do AD: CN=Users
  • Base onde estão os usuários do AD: OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central.
  • Meu usuário admin do AD: Jair Rodrigues.

Vale lembrar uma observação feita por um usuário no site do Viva o Linux de que você não deve tentar reidentar o código, mas apenas descomentar e alterar o conteúdo do que está dentro das aspas. Eis a observação feita por ele:

ATENÇÃO: este arquivo gitlab.rb tem indentação (yaml), sendo assim não mude os espaços, não use tab, cada linha que você descomentar, deixe os espaços exatamente como estavam, não tente deixar mais para esquerda, mais para direita, não mexa na formatação, apenas apague o “#”, mude os atributos e pronto.

Portanto depois de instalado o Gitlab devemos editar suas configurações para integrá-lo ao AD de acordo com o que está descrito abaixo.

   nano /etc/gitlab/gitlab.rb
   gitlab_rails['ldap_enabled'] = true

###! **remember to close this block with 'EOS' below**
   gitlab_rails['ldap_servers'] = YAML.load <<-'EOS'
      main: # 'main' is the GitLab 'provider ID' of this LDAP server
      label: 'LDAP'
      host: 'meu_servidor_do_ad.dominio.central'
      port: 389
      uid: 'sAMAccountName'
      method: 'plain' # "tls" or "ssl" or "plain"
      bind_dn: 'CN=Jair Rodrigues,CN=Users,DC=dominio,DC=central'
      password: 'xererenenen'
      active_directory: true
      allow_username_or_email_login: true
      block_auto_created_users: false
      base: 'OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central'
# user_filter: ''
      attributes:
         username: ['uid', 'userid', 'sAMAccountName']
         email: ['mail', 'email', 'userPrincipalName']
         name: 'cn'
         first_name: 'givenName'
         last_name: 'sn'
EOS

Algumas observações acerca desta configuração

Sobre o atributo base:

Na empresa que trabalho, os usuários do AD estão sob a seguinte hierarquia de pastas: ATIVOS > USUARIOS > PESSOAS, mas quando você utiliza um utilitário chamado ADSI (que está lá instalado no Active Directory) o programa te dá o caminho escrito ao contrário, portanto será assim mesmo, de trás de frente que você irá escrever na configuração do GitLab.


base: 'OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central'

Para entrar no aplicativo ADSI você deve seguir o caminho abaixo.

E para localizar o caminho dos seus usuários siga a árvore até ela lhe mostrar por completo.


Sobre o atributo bind_dn:

Uma das coisas que me confundiu bastante foi o fato de nessa configuração do Gitlab eu não ter de colocar o login do meu usuário administrador, mas sim o nome dele. Portanto preste atenção a isso porque meu usuário tem login jair.rodrigues, mas seu nome é Jair Rodrigues lá no AD.


bind_dn: 'CN=Jair Rodrigues,CN=Users,DC=dominio,DC=central'

Comandos úteis para ocasiões inesperadas ou desesperadas

Para caso você precise consultar as informações sobre sua versão do GitLab instalada


gitlab-rake gitlab:env:info

Para editar o arquivo de configuração do GitLab


nano /etc/gitlab/gitlab.rb

Para reconfigurar seu GitLab logo após ter editado o arquivo de configuração acima

gitlab-ctl reconfigure

Para reiniciar o serviço do Gitlab logo após tê-lo reconfigurado

service gitlab-runsvdir restart

Para abrir um console rails no intuito de alterar alguns parâmetros

gitlab-rails console

Para abrir um console rails e desbloquear um usuarío (o usuário pode ser bloqueado no GitLab após tentar logar digitando a senha errada repetidamente)

gitlab-rails console
user = User.find_by_email("myuser@example.com")
user.state = "active"
user.save
exit

fonte: http://matigado.wordpress.com

fonte: https://forum.gitlab.com/t/how-to-reset-the-admin-password-via-the-rails-console/223

fonte: https://gitlab.com/gitlab-org/gitlab-ce/issues/13179

fonte: https://www.vivaolinux.com.br/artigo/Instalacao-do-Gitlab-e-introducao-ao-Git?pagina=3

fonte: http://blog.dimaj.net/content/updated-howto-enable-ldap-filters-gitlab

Salva Vidas básico do Git (me ajude a entender git por favor!)

Hello!

Hoje vou deixar alguns comandos básicos do git para iniciantes e para caras como eu (iniciantes também).

Para quem não sabe, o Git é um versionador que controla a versão das coisas que você faz. E quando eu digo coisas, digo que não é somente códigos fonte de linguagens que estão sendo colocados, pois colocamos quaisquer tipos de arquivos aí dentro.

fonte: https://mastigado.wordpress.com

Este tutorial básico estava meio encostado e com o nome de “Comandos básicos do Git”, porém resolvi mudar por conta da necessidade que tive de trabalhar não apenas com os comandos básicos, mas também o passo a passo básico e quando utilizá-lo. Por isso listei-os abaixo da forma mais didática que eu encontrei.

Guia:

  • Caso precise ter noção de onde começar a trabalhar como Git, siga para o tópico A.
  • Caso você precise apenas clonar um repositório git e começar a trabalhar nele siga para o tópico E.

Tópicos:

A – Para você que não sabe nada de git – Voltar ao início

Aqui estão esclarecimentos básicos antes de você começar mesmo sem saber nada

Estrutura básica de um repositório git

Tente imaginar essa estrutura como camadas, andares de um prédio ou basicamente uma fase, estado ou um estágio que está acontecendo no momento.

A-01 – Quando você acabou de efetuar o comando git init, você acabou de criar um repositório e seus arquivos estão ali esperando serem versionados, eles são chamados nesse estado de untracked files. Você está no conhecido working directory (diretório de trabalho).

A-02 – Quando você executa o comando git add . (tem esse “.” aí mesmo) está querendo dizer que está retirando os seus arquivos de um working directory e passando para uma staged area.

A-03 – E para este último dizemos que quando você executa o comando commit -m “Meu Primeiro Commit” está retirando os seus arquivos de sua staged area e os colocando numa espécie de fichamento ou se assim posso dizer “uma marcação” daqueles arquivos que você separou com o comando git add . e que depois os colocou dentro de uma caixa de papelão com uma etiqueta chamada de “Meu Primeiro Commit”, lacrou e guardou lá no seu depósito. Ou melhor ainda, você acabou de criar uma versão destes arquivos que você marcou com o comando add e que depois executou o commit.

Contudo por conta deste último ítem veja bem, apesar de a grosso modo estarem “guardados”, estes arquivos continuam sempre no mesmo lugar desde o princípio onde sempre estiveram, eles apenas mudam de estado. Para transferir para a nossa realidade é como se você numa hora estivesse com febre, depois estivesse com a temperatura corporal normalizada, depois cansado após uma longa caminhada, depois dormindo e por aí vai, você sempre estará no planeta terra (seu planeta seria seu repositório git), mas o seu estado vez ou outra alternará.

Agora sim iniciaremos.

B – Comandos básicos de configuração do gitVoltar ao início

B-01 – Antes de começarmos a utilizar o git façamos as configurações globais locais.

Mas ainda antes, deixarei uma observação feita na documentação oficial do Git sobre configurações locais.

Caso você queira sobrepor estas com um nome ou endereço de e-mail diferentes para projetos específicos, você pode executar o comando sem a opção –global quando estiver no próprio projeto.

Repare que risquei o termo globais no título porque tive problemas ao tentar sobrepor estas configurações quando precisei utilizar múltiplos contextos do Git (explico melhor sobre o assunto adiante) e por isso somente recomendo utilizar configuração de repositório local. Portanto agora sim, prossiga.

O user name:


git config --local user.name "Meu Lindo Nome"

B-02 – E o email:


git config --local user.email meulindoemail@centraldeemailslindos.com

C – Criando um repositório local com o intuito de versioná-lo em um repositório remoto que já existeVoltar ao início

C-01 – Para iniciarmos o repositório que queremos trabalhar e depois empurrá-lo para nosso servidor git, primeiramente devemos iniciar o nosso repositório git. Por ora saberemos também que será criada a nossa branch master (mais à frente veremos o que são branches, como utilizar mais de uma ao mesmo tempo e o que você ganha fazendo isso).

git init

Outra observação importante é que este repositório que você acabou de iniciar com o comando git init esteja vazio localmente na sua máquina, ou seja, o cenário é que você acabou de criar um diretório sem nada lá dentro e deu o comando git init.

E por que o diretório deverá estar vazio? Porque caso você tenha algum arquivo em seu repositório remoto (e provavelmente terá localmente após executarmos o comando git pull), será preciso utilizar um comando para mesclar essas duas informações, dos arquivos que você tem e dos que estão lá e aí sim transformá-los num só. Então apenas siga o que digo (para não complicar a sua vida):

  1. Crie um diretório vazio;
  2. Dê o comando git init lá dentro;
  3. Depois adicione a origem como informado no tópico C-02 (logo abaixo);
  4. Em seguida dê o comando git pull conforme orientado em C-03;
  5. E depois prossiga com os outros tópicos;

C-02 – Adicione a origem de seu repositório remoto que irá utilizar. Provavelmente este repositório remoto lhe informará qual o comando correto para você adicioná-lo e você vai ter de se informar sobre isso. Para te ajudar coloquei dois comandos abaixo de como podem se parecer.


git remote add origin https://github.com/blogmastigado/projetoandroid.git


git remote add origin ssh://github.com/blogmastigado/projetoandroid.git

C-03 – Obtenha (com o comando abaixo) todo o arquivo que existe neste repositório remoto antes adicionar arquivos localmente. Dessa forma você terá menos problemas e diminuirá a complexidade do processo de versionamento.


git pull origin master

C-04 – Depois de criado, podemos ver o que tem (e como está) dentro de nosso repositório como o comando abaixo.

git status

O comando git status nos mostra:

Mostra quais são os arquivos que estão fora do controle de versão do git (untracked files).

C-05 – Para adicionar os arquivos em meu controle de versão para que passem a ser “versionados” utilizamos o comando git add (git add nome_do_arquivo_a_ser_versionado). Com este comando, você adiciona as pastas que deseja ao controle de versão. Porém se você digita .(espaço e ponto) após o comando, ele pega tudo que está dentro do diretório em que você está se encontra no momento.

O git add significa que os seus arquivos estão preparados para serem comitados e ao invés de os arquivos estarem listados como untracked files, serão listados como new file(novo arquivo).

git add .

Se você der o comando git status (novamente) depois de git add, ele mudará de estado para mostrar os arquivos que estão para serem comitados.

C-06 – Commit! Logo após que você adiciona os seus arquivos para serem “comitados” com o comando git add é hora de utilizar o comando commit:


git commit -m "O meu primeiro commit no git"

E por que fazer o commit?

Toda a vez que você altera um arquivo, você “comita”, ou seja, você grava aquela versão.
Quando você digita git commit -m, você está informando que vai deixar uma mensagem de identificação sobre a versão que você está gerando.

Após executar o comando, ele irá gerar um código para este seu commit(algo como: master (root-commit) 4d68ec3] “O meu primeiro commit no git”).

Você também pode dar um git status para ver como as coisas estão saindo. Possivelmente ele irá dizer que não será preciso fazer mais nada porque tudo o que foi marcado para ser “comitado”, já foi comitado.

C-07 – E para colocar os meus arquivos lá no meu servidor git remoto?

Para empurrar os arquivos versionados pelo meu commit anterior utilizo-me dos comandos abaixo.

git push -u origin master

Caso Problemas de autenticação com erro 403

Repare que pode existir endereço com https ou http, porém as vezes você pode ser supreendido com um erro do tipo “remote: Access denied” junto com “The requested URL returned error: 403”.
Para resolver este tipo de problema alguns indicam seguir no diretório/caminho .git/config que está dentro da raiz do seu projeto git, abra o arquivo config e altera o parâmetro http ou https do atributo url para ssh, depois salve, feche o arquivo e tente novamente enviar para o servidor remoto.

D O que são branches e para que precisamos gerenciá-las! – Voltar ao início

Até agora só trabalhamos com uma branch chamada de master e ela é praticamente a branch padrão que todo repositório git cria quando ele é iniciado com o comando git init. Por vezes trabalhamos em equipe e deixar que todos modifiquem o mesmo código pode dar problema e por isso devemos ter o hábito de criar uma ou mais branchs além da master e gerenciá-las de forma adequada.

Como dito antes, gerenciar branches é necessário quando se trabalha em equipe porque cada um costuma ter uma responsabilidade própria. E quando você cria uma nova branch a partir de uma já existente, está dizendo que vai pegar tudo o que você fez naquela branch atual que está trabalhando (no nosso caso é a master) e colocar numa nova branch de forma igualzinha, bonitinha e cheirozinha como já estava antes, sacou? Você faz um clone do estado atual de sua branch para uma outra e esse tipo de processo é o que chamamos de fork. E a partir deste raciocínio você tem duas opções para começar a trabalhar em outra branch. São elas:

D-01A primeira opção é criarmos uma nova branch, mas você só consegue fazer isso se na sua branch atual já tiver adicionado alguns arquivos à sua staged área (se você não sabe o que é isso recomendo ler o tópico Estrutura básica do git logo no início deste tutorial) e logo em seguida ter dado um commit nesses arquivos. Por ora vamos criar uma branch executado o comando abaixo.


git branch novabranch

D-02A segunda opção é você acessar um diretório remoto partindo do princípio que você seguiu os passos do item C-02 e adicionou um repositório remoto como a origin do nosso repositório git local. Portanto neste caso supomos que você tem uma branch neste repositório que você adicionou e queremos acessá-la. Para isso utilizamos o comando abaixo.

git checkout -b origin minhabranchremota

ou

 
git checkout minhabranchremota 

E em seguida pegar os arquivos contidos nela e trazer para o nosso repositório local.

git pull

D-03 – E para listar e trocar de branch?

Caso precisemos listar as branches que temos acesso localmente podemos utilizar do comando git branch. Desta forma:

git branch

Em seguida nos será listado as branchs que temos disponíveis. Algo como isso:

$ git branch
 master
* novabranc

ou

$ git branch
 master
* origin/minhabranchremota

E para trocarmos de branch utilizamos do comando git checkout nome_da_branch_que_quero_intercalar.

git checkout novabranch
git checkout minhabranchremota

E Clonando repositórios remotos para trabalharmos em cima deles

Pois bem, sabe quando já criamos um repositório remoto e ele já contém algum arquivo lá dentro e queremos enviar nossas modificações para ele? Difícil né? Mais adiante falaremos sobre como mesclar, juntar, “merjar” essas diferenças entre o que está no nosso repositório local e o que foi colocado no repositório remoto após criarmos um repositório local sem antes ver o que já existia no remoto ou quando pegamos as últimas alterações de um remoto e nesse meio tempo alteramos ainda mais coisas lá no remoto enquanto ainda nem enviamos as alterações feitas no nosso repositório local. Então por ora iremos nos ater apenas a iniciar um repositório a partir de um clone de um remoto.

E-01 Quando formos começar a codificar algo a partir de um clone, esqueça as configurações iniciais do git, apenas utilize o comando para clonar o repositório e comece a trabalhar nele normalmente.

 
git clone https://github.com/blogmastigado/projetoandroid.git

Para o caso de você precisar colocar os arquivos de volta no repositório que acabou de clonar

Primeiro faça uma única vez a configuração do repositório seguindo os passos B-01 e B-02 do tópico B.

Se adicionou novos arquivos ao diretório que clonou, siga os passos A-02 e A-03 do tópico A. E para enviar os arquivos de volta siga as intruções do passo C-06 do tópico C.

E é isso.

DICAS DIVERSAS

Para caso aconteça um problema de autenticação (erro 403) seja nos repositórios do GitLab

01 – Verifique se já existe uma chave em seu SO.

Para Windows faça:

type %userprofile%\.ssh\id_rsa.pub

Ou pode utilizar o Git Bash no Windows, GNU/Linux, macOS, PowerShell:

type %userprofile%\.ssh\id_rsa.pub

O teste acima é meramente ilustrativo porque estou contando que esta chave já existe, por isso não vou deixar aqui como gerá-la (todas estas informações estão em http://seu_servidor_gitlab/help/ssh/README).

02 – Para copiar esta chave existente para o GitLab

No Windows:

type %userprofile%\.ssh\id_rsa.pub | clip

No Mac OS:

pbcopy &lt; ~/.ssh/id_rsa.pub

No GNU/Linux (requer que o pacote xclip esteja instalado):

xclip -sel clip &lt; ~/.ssh/id_rsa.pub

Para o Git Bash no Windows / Windows PowerShell:

cat ~/.ssh/id_rsa.pub | clip

03 – Depois siga para o Gitlab

Após executado os comandos acima siga para o Gitlab, Profile e Keys. Cole a chave lá e clique em Add Key.
Se ainda tiver problema no seu repositório, readicione-o com as informações contidas em seu repositório remoto no Gitlab.

DICAS DIVERSAS (para quando você estiver agarrado em alguma coisa)

Para apagar algumas configurações globais que podem te atrapalhar quando você trabalha com múltiplos contextos

Pois bem, por vezes trabalhamos com múltiplos contextos de git (mais precisamente múltiplas contas de email) e nessas horas podemos esbarrar em problemas de autenticação ao fazer push (unable to access, The requested URL returned error: 403) mesmo com o nosso repositório estando com configurações locais corretas. Então neste caso você pode executar os comandos abaixo.

Este primeiro para indicar que queremos que o usuário utilize-se apenas das configurações locais.

git config --global user.useConfigOnly true

A segunda para limpar as configurações globais se existirem

git config --global --unset user.name
git config --global --unset user.email

A terceira será para limpar as informações de credenciais globais guardadas

git config --global --unset credential.helper

E por fim, a última é para apagar as informações de credenciais contidas no sistema (este comando realmente resolveu meu problema), só que para executar este comando você deverá estar logado no Git Bash como usuário administrador.

git config --system --unset credential.helper

Pronto. Agora é só executar o git push normalmente que provavelmente será pedido login e senha.

Para listar as configurações do Git

 
git config --list

Ou

 
git config --list --show-origin

Lembrando que a parte das configurações locais listadas estão contidas no arquivo .git/config que está dentro do seu repositório local e portanto também podem serem editadas por um editor de texto como um Notepad.

Para checar a versão do seu Git

 
git --version

Para certificar-se que se certificar de que a origem foi obtida

 
git fetch origin

Para visualizar informações de seu repositório remoto

 
git remote -v 

Para visualizar informações se foi obtida as ramificações de seu repositório remoto

 
git remote -avv 

Para remover o repositório origin

 
git remote remove origin 

Para armazenar suas credenciais de repositório

Digite o comando para armazenar a credencial localmente e depois para enviar os arquivos para o repositório remoto.

 
git config credential.helper store
git push http://example.com/repo.git 

Em seguida serão pedidos usuário e senha para seu repositório remoto apenas uma vez.

 
Username: <digite seu username>
Password: <digite seu password>

Para reconfigurar a url do seu repositório remoto

 
git remote set-url origin https://github.com/blogmastigado/projetoandroid.git

Para armazenar configurações de credenciais por um tempo definido

No caso abaio irá armazenar por 60 minutos.

 
git config credential.helper 'cache --timeout=3600'

Para forçar o envio do repositório local à sua origin

git push -u --force origin master

Para descobrir o local onde está o arquivo de configuração global

No Windows 7 comumente no caminho abaixo.

C:\Users\MyLogin\.gitconfig

Ou você pode executar o comando abaixo e observar onde está localizado o arquivo .gitconfig

git config --list --show-origin

A respeito deste comando (–force)

Em virtude do erro: “! [rejected] master -> master (fetch first) error: failed to push” é provável que o comando push não seja o adequado no momento.
A resposta está lá, o git está dizendo para você buscar primeiro (primeiro o pull). Provavelmente alguém mais já enviou para a origin (fez o push). Consequentemente você tem que buscar (fazer o pull), mesclar o changeset (fazer o merge), daí você poderá empurrar (fazer o push) outra vez.
Se você não conseguiu fazer normalmente o push e “forçou a barra para fazer” (se fizer usando a opção –force), você pode estragar o histórico de alterações (na verdade provavelmente você irá estragar esta linha do tempo).

Para maiores detalhes você pode consultar este post do StackOverflow que foi de onde retirei esta bela explicação sobre o uso forçar o push em um repositório.
fonte: http://stackoverflow.com/questions/28429819/rejected-master-master-fetch-first

Essa fonte abaixo foi uma das minhas fontes de inspiração e meu ajudou muito (dêem uma força para o canal do RB Tech)
fonte: https://www.youtube.com/playlist?list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0

fonte: https://mastigado.wordpress.com

fonte: https://blog.da2k.com.br/2015/02/04/git-e-github-do-clone-ao-pull-request/

fonte: https://git-scm.com/book/pt-br/v1/Git-Essencial-Obtendo-um-Reposit%C3%B3rio-Git

fonte: https://git-scm.com/book/pt-br/v2/Git-Branching-Branch-Management

fonte: https://git-scm.com/book/pt-br/v1/Primeiros-passos-Configura%C3%A7%C3%A3o-Inicial-do-Git

fonte: https://git-scm.com/docs/git-credential-store

fonte: https://collectiveidea.com/blog/archives/2016/04/04/multiple-personalities-in-git

fonte: https://stackoverflow.com/questions/15381198/remove-credentials-from-git

fonte: https://stackoverflow.com/questions/2114111/where-does-git-config-global-get-written-to

%d blogueiros gostam disto: