quarta-feira, 15 de junho de 2011

Vírus que transforma documentos em atalhos, como reparar?


Vírus que transforma documentos em atalhos, como reparar?


Problema :

Vírus que transforma documentos em atalhos, como reparar?

Soluções:

1. Esta solução foi proposta por Francisco Rodrigues
Em primeiro lugar você precisa remover o vírus, que talvez até já tenha sido removido.
Depois,

No prompt do DOS (Ainda uso muito o DOS) digite:

cd\
dir *.
O comando acima mostra as pastas - Você observará que algumas sumiram. As que sumiram viraram "falsos" atalhos. Então, você digita:

dir *.lnk [Enter], dir *.scr [Enter], etc
Os nomes dos falsos atalhos são os nomes das suas pastas. Anote e apague os falsos atalhos, digitando:
del *.lnk [Enter], del *.scr [Enter], etc

Agora é só remover os atributos "S" e "H" das pastas, digitando o seguinte:
attrib -s -h [Enter]

Infelizmente, no meu caso, o comando "attrib *.* -s -h [Enter]"não funcionou e, precisei remover o atributo das pastas, uma a uma.

2. Esta solução foi proposta por André
Você deve clicar com o botão direito no atalho e depois ir nas propriedade> atalhos. Assim, vai ver que o destino do arquivo esta com o nome errado. Ou seja, primeiro vem o nome do vírus. Você deve excluir o nome do vírus e deixar o nome do caminho correto.

3. Outra solução é proposta por Taborda
Você deve colocar um /S /D no começo do comando. Desta forma ele pegará todos os arquivos e pastas que você tiver na Raiz.

Isto é útil quando se tem arquivos no pen drive: agiliza bastante.
EX: F:\>attrib /S /D -s -h

terça-feira, 14 de junho de 2011

31. maio 2011 10:48

Fala galera, uma das alegrias de se trabalhar com o SQL Server Reporting Services 2008 R2 para criar seus graficos e dashboards, é a imensa possibilidade de customizá-lo de acordo com a sua necessidade.

Vou mostrar um exemplo de como inserir um segundo ponteiro em um gauge de 360º (mas poderia ser em outro, sem problemas). Por padrão, só aparece um ponteiro por gauge.

Para facilitar a explicação, vou usar o AdventureWorks que é facil de encontrar em qualquer base de dados SQL Server nas maquinas de vocês. Para o exemplo, criei essa Stored Procedure:

   1:  CREATE PROC RetornarValores
   2:  AS
   3:  SELECT tbBlack.Preco [Preco_B]
   4:       , tbSilver.Preco [Preco_S]
   5:       , tbCompleta.Preco [Preco_C]
   6:   FROM
   7:   
   8:  /* VALOR DOS PRODUTOS DE COR PRETA */ 
   9:  ( select SUM(V.StandardPrice) [Preco] from Purchasing.ProductVendor V
  10:  INNER JOIN Production.Product P
  11:  on v.ProductID = P.ProductID
  12:  where p.Color = 'Black') [tbBlack]
  13:   
  14:  /* VALOR DOS PRODUTOS DE COR PRATA */ 
  15:  ,( select  SUM(V.StandardPrice) [Preco] from Purchasing.ProductVendor V
  16:  INNER JOIN Production.Product P
  17:  on v.ProductID = P.ProductID
  18:  where p.Color = 'Silver') [tbSilver]
  19:   
  20:  /* VALOR DE TODOS OS PRODUTOS */ 
  21:  ,( select SUM(StandardPrice) [Preco] from Purchasing.ProductVendor) [tbCompleta]

A idéia é que retorne um valor das vendas para os produtos de cor preta, de cor prata e do total de todos produtos. Se você criar essa procedure em seu bando AdventureWorks, terá um retorno como esse:

image

Ótimo, se você está vendo esse mesmo resultado, já temos a parte do banco de dados pronta. Agora é criar o relatório em cima disso. Vou partir do pressuporto que você já sabe criar um Shared Data Source e Shared Dataset, mas se não sabe, clique neste link: Shared Data Source e Shared Dataset no Reporting Services 2008 R2

Depois de criar o Shared Data Source e o Shared Dataset, é hora de incluir o gauge no relatório. Vou selecionar o primeiro que apareceu, Radial de 360º. Vou selecionar o Shared Dataset que eu criei com base na query acima e vou clicar em OK. O Gauge vai aparecer no relatório. Se você não entendeu bem como fazer isso, dê uma olhada nesse link: Como inserir Gauges (indicadores) em seus relatórios

Agora seu relatório deve estar assim:

image

Chegou a hora de configurarmos para receber os ponteiros. Para isso, clicamos duas vezes na área branca ao lado do Gauge, e o wizard de configuração é mostrado. Agora volte ao seu Gauge e selecione o ponteiro amarelo, a tela deve ficar parecida com isso:

image

Vá até o wizard do lado direito, clique na combo box escrita (Unspecified) e selecione o ítem PRECO_B – Que é o valor das vendas dos produtos de cor preta.

Ainda com o ponteiro selecionado, vá as as propriedades (aperte F4 para elas aparecerem), vá ao item FillColor e FillGradientEndColor e informe Black para ambos. Você verá seu ponteiro ficando na cor preta.

Se ocorreu tudo certo, seu Gauge estará assim:

image

Agora vamos adicionar o segundo ponteiro, o prata.

Para isso, clique com o botão direito no seu Gauge e vá até a opção Add Pointer:

image

Você verá um novo ponteiro inserido no seu Gauge, mas ainda sem configuração. Veja como deve estar seu relatório logo após você adicionar o segundo ponteiro:

image

Vamos repetir os mesmos passos do primeiro, só as informações que vamos configurar para esse segundo ponteiro serão referentes à ele. E elas são:

No wizard da direita, selecione o ítem (Unspecified) e mude para Preco_S. Mantendo esse ponteiro selecionado vá até as propriedades (aperte F4 para elas aparecerem), modifique os item FillColor e FillGradientEndColor para Silver.

Seu Gauge deverá ficar assim:

image

O ultimo passo é informar qual o valor maximo que o seu Gauge vai mostrar. Vou deixar esse valor configurado para 1000.

Aqui está fixo o valor maximo do gauge, mas para ver como parametrizar esta configuração, clique aqui:Parametrizando valor máximo no Gauge – SSRS 2008 R2

Para alterar esse valor, precisamos selecionar o Gauge e ir nas propriedades (aperte F4 para elas aparecerem). Vá até o item Scales e clique nos [...] do lado do texto (Collection). Um wizard se abrirá, procure o item (MaximumValue) e altere de 100 para 1000.

image

Pronto, seu Gauge está configurado para visualizar dois ponteiros, um na cor preta e outro na prata. Se você seguiu os passos apresentados acima, terá um resultado como esse:

image

Agora é contigo adicionar quantos ponteiros forem necessários Alegre


Retirado do site: http://www.diegonogare.net/Blog/post/Como-inserir-2-ponteiros-em-um-Gauge-no-SSRS-2008-R2.aspx


sexta-feira, 10 de junho de 2011

Retirado do site http://imasters.com.br/artigo/3230/visual_basic/criando_minha_primeira_dll/
Criando minha primeira DLL

Hoje vamos falar sobre “Dynamically Linked Libraries”. Com certeza você conhece não é? Não? Tudo bem, deve ser o fato de estar em Inglês. Traduzindo: “Bibliotecas Dinamicamente Ligadas”, agora sim? Ainda não? Então vamos ao popular DLL.

Neste artigo vamos analisar como tudo começou e fazer um exemplo simples, bem relativo ao tema “Criando minha primeira DLL”. Não será nenhum exemplo do estilo “Hello World”, mas também nenhum mega-exemplo ensinando como acabar com todos os problemas do Windows, mas sim uma função para Leitura e outra para Escrita em Arquivo INI usando e técnica de implementar o código em DLL.

Introdução

Nada melhor antes da prática do que uma boa dose de teoria, não é mesmo? Vamos falar um pouco sobre DLL e Arquivos INI.

Dlls

Nos primórdios da informática os programas eram constituídos apenas de um arquivo executável, onde no mesmo havia todas as informações e instruções necessárias para seu funcionamento, porém como há programas e PROGRAMAS, tínhamos paralelamente aos programas de porte simples os complexos, estes sim, continham diversos executáveis.

Com o decorrer do tempo, isso obviamente só aumentou, consideravelmente após o início da utilização de interface gráfica chamada de GUI (Graphical User Interface ou Interface Gráfica de Usuário), que fez com a divisão do programa em vários executáveis se tornasse inviável na questão de produtividade, já que o código entre os executáveis não podia ser compartilhado. Ou seja, se você tinha uma função que era utilizada em todos os executáveis de seu programa, você deveria implementá-la em cada um deles (ou melhor, dizendo fazer em uma e CTRL+C e CTRL+V em outra).

Para solução disto, nossos amigos projetistas do Windows começaram a usar uma estratégia denominada “Linkagem Dinâmica”, que resumidamente se explica em: o programador informar no código a localização de uma biblioteca de função (externa ao programa) e o compilador “juntar” as funções da biblioteca com o código implementado pelo programador. Em síntese, as funções são retiradas do arquivo executável e armazenadas em uma biblioteca, contudo, temos inúmeras vantagens, duas das mais relevantes são:

Compartilhamento do Código, já que vários executáveis podem se referenciar a mesma biblioteca.

Atualizações do Programa se torna mais fácil já que só é preciso alterar as bibliotecas e não o executável evitando ter que reinstalar o programa.

Essas bibliotecas são padrões de todos os sistemas da família Windows, como exemplos têm-se as famosas API (Application Program Interface ou Aplicação de Programa de Interface) do Windows, que em grande parte dos casos são baseadas nesse tipo de biblioteca.

As APIs (que em resumo são bibliotecas que contêm informações de como devem ser os caixa de textos, botões de comando, caixa de mensagens, etc) propiciam ao programador menos trabalho no desenvolvimento e além de tudo determina uma padronização de interface nos programas.

Você deve estar se indagando, “Legal saber tudo isso, mas onde isso me ajuda?”. Sem dúvidas, a principio essa técnica parece um tanto quanto distante da nossa realidade de programação, já que não estamos desenvolvendo nenhum Sistema Operacional (pelo menos eu não), porém, se você analisar com um pouco mais de atenção, notará que isso é ao contrário do que se imagina. Vou citar dois exemplos práticos:

01. Digamos que você tem uma função que serve para que o usuário via e-mail entre em contato com você para esclarecimento de dúvidas. Tudo bem até aí, porém você possui 15 aplicações que se utilizam dessa mesma função. Certo dia você precisa mudar o e-mail de contato, como fazer? Gerar um novo executável de cada uma das aplicações informando o novo e-mail de contato e enviar aos clientes, sim pode ser, ou deixar essa função em uma DLL, assim, você não precisa dispor uma nova compilação do executável, somente da DLL que contém a função.

02. Você desenvolveu uma função super útil e quer que todos “desfrutem” da mesma função, porém não quer disponibilizar o código em si (mui amigo você em!!!), como fazer? Simples, coloque a função em uma DLL, nela seu código estará 100% seguro (pelo menos até onde conheço não existem “decompiladores” para DLL) e todos podem utilizar a sua função.

Arquivos INI

Em resumo são arquivos utilizados para armazenamento e recuperação de dados, como um exemplo bastante simples de utilização, podemos citar o armazenamento da posição Top e Left do Form no momento em que o mesmo foi fechado, para que quando seja aberto novamente se se posicione onde estava anteriormente.

A estrutura funcional de um Arquivo INI é similar a um banco de dados, onde temos:

Seções: Conjunto que contêm chaves e Valores, em analogia a um Banco de Dados pode-se dizer que é a Tabela.

Chaves: Usado para Identificação correta dos Valores, em analogia a um Banco de Dados pode-se dizer que é o Campo.

Valores: É usado para atribuição de um Valor a uma chave, em analogia a um Banco de Dados pode-se dizer que é o Dado contido no Campo.

Estrutura Arquivo INI

Estrutura Banco de Dados

[Clientes]

Nome=Eledio de Souza Junior

Algo que acho importante mencionar é que as operações feitas em Arquivos INI, tanto de leitura como de escrita não retornam nenhum erro, assim, se o Arquivo INI não existir e você tentar ler algum valor de uma chave ele retornará "" (vazio), caso tente escrever ele criará o arquivo, a seção e a chave e definirá o valor informado, fica a seu critério avaliar até que ponto esse “não retorno de erro” pode ajudar ou não.

Desenvolvimento

Inicie o Visual Basic, na tela New Project, escolha a opção ActiveX DLL.

Renomeie o Projeto como ArquivoINI e a classe criada: INI, e nada mais prático do que falar de DLL usando uma, na classe Main declare as seguintes APIs, sendo a primeira para Escrita e a segunda Leitura no Arquivo INI:

01. Private Declare Function WritePrivateProfileString Lib "kernel32" Alias "WritePrivateProfileStringA" (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpString As Any, ByVal lpFileName As String) As Long

02. Private Declare Function GetPrivateProfileString Lib "kernel32" Alias "GetPrivateProfileStringA" (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpDefault As String, ByVal lpReturnedString As String, ByVal nSize As Long, ByVal lpFileName As String) As Long

Declare a seguinte Variável para armazenamento e recuperação do diretório do arquivo INI.

Private ArqINI as String
Implemente as seguintes funções:
Public Function ReadINI(ByVal Secao As String, ByVal Chave As String)
Dim RET As String
RET = Space$(255)
RetLen = GetPrivateProfileString(Secao, Chave, "", RET, Len(RET), ArqINI)
RET = Left$(RET, RetLen)
ReadINI = RET
RET = Empty
End Function

Public Sub WriteINI(ByVal Secao As String, ByVal Chave As String, ByVal Valor As String)
WritePrivateProfileString Secao, Chave, Valor, ArqINI
End Sub

Onde, a primeira utiliza a API GetPrivateProfileString serve para Ler dados do Arquivo INI baseando-se na Seção e Chave passada a ela, e a segunda por sua vez, utiliza a API WritePrivateProfileString serve para Escrever no Arquivo INI.

Agora vamos criar duas propriedades para nossa DLL uma delas para “setar” o Diretório do Arquivo INI, e outra para Retornar o Diretório do Arquivo INI, são elas:

Public Property Let SetDiretorioIni(ByVal Diretorio As String)
ArqINI = Diretorio
End Property

Public Property Get GetDiretorioIni() As String
GetDiretorioIni = ArqINI
End Property

Por último (na questão de funções) vamos fazer uma função para verificar a existência do arquivo informado. Para isso usaremos a função Dir que é intrínseca (padrão) no VB, a mesma recebe o diretório e o tipo a ser validado, no caso um Arquivo. Se o seu retorno for “” (vazio) então o arquivo não existe, caso contrário retornará o nome do arquivo, o código segue abaixo.

Public Property Get ExisteArquivo() As Boolean
ExisteArquivo = IIf(Dir(ArqINI, vbArchive) = "", False, True)
End Property

Bom é isso. Aí está sua primeira DLL implementada, simples, porém funcional. Agora compile sua DLL no Diretório System32 da sua pasta Windows.

Agora vamos utilizá-la. Para isso crie um novo projeto Standard EXE e nomeie-o deExemploINI. “Desenhe” os controles conforme a tabela seguinte:

Form1 – Propriedade e Controles

Tipo

Propriedades

Form

Name = frmMain
Caption = Principal
BorderStyle = 3 'Fixa

Label

Name = Label
Caption = &Entrada
Index = 0

TextBox

Name = txtEntrada
Text=””

CommandButton

Name = cmdEscrever
Caption = &Escrever

Label

Name = Label
Caption = &Resultado
Index = 1

TextBox

Name = txtResultado
Text=””

CommandButton

Name = cmdLer
Caption = &Ler

Label

Name = Label
Caption = Dire&tório
Index = 2

CommandButton

Name = cmdSair
Caption = &Sair

TextBox

Name = txtDiretorio
Text=””

Para podermos utilizar as funções da DLL criada anteriormente devemos nos referenciar a ela, para isso, no menu Project escolha o item References, e localize a sua DLL, no casoArquivoINI.dll, caso ela não esteja na lista clique em Browse e a localize.

Feito isso vá ao código do frmMain e faça a declaração da classe da seguinte forma:

Private INI As New ArquivoINI.INI

Se você não entendeu o que está acontecendo, calma, é o seguinte, você para utilizar uma função de uma determinada classe de uma biblioteca precisa ter a mesma declarada, no exemplo acima declaremos o objeto INI do tipo ArquivoINI.INI.

No evento load do form vamos informar o diretório do arquivo INI a ser utilizado (no exemplo será no diretório do executável com o nome de config.ini) e também para enfatizaremos a função de verificação de existência do arquivo:

Private Sub Form_Load()
txtDiretorio.Text = App.Path & "\Config.INI"
INI.SetDiretorioIni = txtDiretorio.Text

If Not (INI.ExisteArquivo) Then MsgBox "ATENÇÃO: Arquivo '" & INI.GetDiretorioIni & "' não foi Encontrado" & vbNewLine & "Para Execução das Operações será criado um novo arquivo", vbCritical

End Sub

Basta agora implementar os botões de leitura e escrita no arquivo, no evento click dos CommandButton cmdLer e cmdEscrever, conforme a seguir:

Private Sub cmdEscrever_Click()
INI.WriteINI "LOGIN", "ULTUSUARIO", Trim(txtEntrada.Text)
End Sub

Private Sub cmdLer_Click()
txtResultado.Text = INI.ReadINI("LOGIN", "ULTUSUARIO")
End Sub

E como sempre o indispensável cmdSair

Private Sub cmdSair_Click()
Unload Me
End Sub

É isso aí, está pronto!!! Caso queira o código fonte clique aqui.