private void SetProperty(object result, string propertyName, object value)
{
PropertyInfo pi = result.GetType().GetProperty(propertyName);
/// Como tem duas propriedades eu tenho que setar os valores da propriedades do RPS a assinatura e feita pelo metodo especifico
if (propertyName.Equals("Rps"))
{
SetProperty(result, "InfRps", ((tcRps)value).InfRps);
SetProperty(result, "Signature", ((tcRps)value).Signature);
}
else
if (pi != null)
{
if (!String.IsNullOrEmpty(value.ToString()))
{
Type t = Nullable.GetUnderlyingType(pi.PropertyType) ?? pi.PropertyType;
/// Melhorar a conversao
if (t.Name.Equals("Rps[]"))
{
Rps[] obj = new Rps[1];
obj[0] = ((Rps)value);
pi.SetValue(result, obj, null);
}
else
{
object safeValue = (value == null) ? null : Convert.ChangeType(value, t);
pi.SetValue(result, safeValue, null);
}
}
}
}
public async Task GetCommodity()
{
// - Given
var resources = new Resources();
var commodityId = 2;
// - Setup the Mock to Repository
Commodity commodity = TestSetup.BuildCommodity(commodityId);
resources.Repository.Setup(Rps => Rps.GetCommodity(commodityId))
.Returns(Task.FromResult <Commodity>(commodity));
// - When
var result = await resources.Controller.GetCommodity(commodityId);
// - Then
Assert.IsNotNull(result);
var okObjectResult = result.Result as OkObjectResult;
Assert.AreEqual(200, okObjectResult.StatusCode);
var commodityResult = okObjectResult.Value as Commodity;
Assert.AreEqual(commodityId, commodityResult.CommodityId);
Assert.AreEqual(commodity.CommodityCode, commodityResult.CommodityCode);
Assert.AreEqual(commodity.CommodityDescription, commodityResult.CommodityDescription);
}
public async Task DeleteCommodity()
{
// - Given
var resources = new Resources();
var commodityId = 2;
// - Setup the Mock to Repository
Commodity commodityOut = TestSetup.BuildCommodity(0);
resources.Repository.Setup(Rps => Rps.DeleteCommodity(commodityId))
.Returns(Task.FromResult <Commodity>(commodityOut));
// - When
var result = await resources.Controller.DeleteCommodity(commodityId);
// - Then
Assert.IsNotNull(result);
var okObjectResult = result.Result as OkObjectResult;
Assert.AreEqual(200, okObjectResult.StatusCode);
var commodityResult = okObjectResult.Value as Commodity;
Assert.AreEqual(0, commodityResult.CommodityId); // - returns an undo object that is ready to be inserted again.
Assert.AreEqual(commodityOut.CommodityCode, commodityResult.CommodityCode);
Assert.AreEqual(commodityOut.CommodityDescription, commodityResult.CommodityDescription);
}
public async Task GetCommodities()
{
// - Given
var resources = new Resources();
string filterDescription = string.Empty;
// - Setup of Mock for IRepository
List <Commodity> commodities = TestSetup.BuildCommodities();
resources.Repository.Setup(Rps => Rps.GetCommodities(String.Empty))
.Returns(Task.FromResult <IEnumerable <Commodity> >(commodities));
// - When
var result = await resources.Controller.GetCommodities("");
// - Then
Assert.IsNotNull(result);
var okObjectResult = result.Result as OkObjectResult;
Assert.AreEqual(200, okObjectResult.StatusCode);
var commoditiesResult = okObjectResult.Value as List <Commodity>;
Assert.AreEqual(commodities.Count, commoditiesResult.Count);
}
public async Task UpdateCommodity()
{
// - Given
var resources = new Resources();
var commodityId = 2;
// - Setup the Mock to Repository
Commodity commodityIn = TestSetup.BuildCommodity(0);
Commodity commodityOut = TestSetup.BuildCommodity(commodityId);
// - Validation in Controller method
commodityIn.CommodityGroupId = commodityId;
// - Two methods to mock...
resources.Repository.Setup(Rps => Rps.UpdateCommodity(commodityIn))
.Returns(Task.FromResult <Commodity>(commodityOut));
resources.Repository.Setup(Rps => Rps.CommodityGroupExists(commodityId))
.Returns(Task.FromResult <bool>(true));
// - When
var result = await resources.Controller.UpdateCommodity(commodityIn);
// - Then
Assert.IsNotNull(result);
var okObjectResult = result.Result as OkObjectResult;
Assert.AreEqual(200, okObjectResult.StatusCode);
var commodityResult = okObjectResult.Value as Commodity;
Assert.AreEqual(commodityId, commodityResult.CommodityId);
Assert.AreEqual(commodityOut.CommodityCode, commodityResult.CommodityCode);
Assert.AreEqual(commodityOut.CommodityDescription, commodityResult.CommodityDescription);
}
public async Task UpdateCommodityGroup()
{
// - Given
var resources = new Resources();
var commodityGroupId = 2;
// - Setup the Mock to Repository
CommodityGroup commodityGroupIn = TestSetup.BuildCommodityGroup(0);
CommodityGroup commodityGroupOut = TestSetup.BuildCommodityGroup(commodityGroupId);
resources.Repository.Setup(Rps => Rps.UpdateCommodityGroup(commodityGroupIn))
.Returns(Task.FromResult <CommodityGroup>(commodityGroupOut));
// - When
var result = await resources.Controller.UpdateCommodityGroup(commodityGroupIn);
// - Then
Assert.IsNotNull(result);
var okObjectResult = result.Result as OkObjectResult;
Assert.AreEqual(200, okObjectResult.StatusCode);
var commodityGroupResult = okObjectResult.Value as CommodityGroup;
Assert.AreEqual(commodityGroupId, commodityGroupResult.CommodityGroupId);
Assert.AreEqual(commodityGroupOut.CommodityGroupCode, commodityGroupResult.CommodityGroupCode);
Assert.AreEqual(commodityGroupOut.CommodityGroupDescription, commodityGroupResult.CommodityGroupDescription);
Assert.AreEqual(commodityGroupOut.Commodities.Count, commodityGroupResult.Commodities.Count);
}
public static void Main()
{
Rps.Test(Match(PlayerChoice.Rock, PlayerChoice.Rock), Result.Draw);
Rps.Test(Match(PlayerChoice.Paper, PlayerChoice.Paper), Result.Draw);
Rps.Test(Match(PlayerChoice.Scissors, PlayerChoice.Scissors), Result.Draw);
Rps.Test(Match(PlayerChoice.Rock, PlayerChoice.Scissors), Result.FirstWin);
Rps.Test(Match(PlayerChoice.Rock, PlayerChoice.Paper), Result.FirstLose);
Rps.Test(Match(PlayerChoice.Paper, PlayerChoice.Rock), Result.FirstWin);
Rps.Test(Match(PlayerChoice.Paper, PlayerChoice.Scissors), Result.FirstLose);
Rps.Test(Match(PlayerChoice.Scissors, PlayerChoice.Paper), Result.FirstWin);
Rps.Test(Match(PlayerChoice.Scissors, PlayerChoice.Rock), Result.FirstLose);
}
/// <summary>
///
/// </summary>
private void SetRpsNumber()
{
var rpsNumber = RequestNextRpsNumber();
var numberNodes = Rps.Descendants(FDefaultNamespace + "Numero");
if (numberNodes.Count() == 0)
{
TLog.Write("Xml tag 'numero' not found at Smart RPS - xml: " + Rps.ToString(SaveOptions.DisableFormatting));
throw new ApplicationException("O xml do Smart com o RPS para fazer a conversão para nota fiscal está inválido. Tag 'numero' não encontrada.");
}
var numberNode = numberNodes.First();
numberNode.SetValue(rpsNumber);
}
/// <summary>
///
/// </summary>
private void SetName()
{
var name = String.Empty;
try
{
switch (Place)
{
case "SJC":
name = Rps.Descendants(FDefaultNamespace + "Tomador").Descendants(FDefaultNamespace + "Nome").First().Value;
break;
default:
name = String.Empty;
break;
}
}
catch {}
Name = name;
}
/// <summary>
///
/// </summary>
private void SetID()
{
var id = String.Empty;
try
{
switch (Place)
{
case "SJC":
id = Rps.Descendants(FDefaultNamespace + "NumeroLoteSJC").First().Value;
Rps.Descendants(FDefaultNamespace + "NumeroLoteSJC").Remove();
break;
default:
id = String.Empty;
break;
}
}
catch { }
ID = id;
}
private void SalvarDadosEnvio(Rps dados, string xmlDados, string xmlRetorno, string arquivoImportacao, string conteudoImportacao, string arquivoRemessa, string arquivoRetorno)
{
try
{
DadosEnvioTO dadosEnvio = new DadosEnvioTO();
dadosEnvio.NumeroLoteRps = Convert.ToString(dados.NumeroLote);
dadosEnvio.Data = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
dadosEnvio.XMLRemessa = xmlDados;
dadosEnvio.XMLRetorno = xmlRetorno;
dadosEnvio.ArquivoImportacao = arquivoImportacao;
dadosEnvio.ArquivoRemessa = arquivoRemessa;
dadosEnvio.ArquivoRetorno = arquivoRetorno;
dadosEnvio.ConteudoArquivoImportacao = conteudoImportacao;
DadosEnvioDAL.Insert(dadosEnvio);
}
catch (Exception ex)
{
throw;
}
}
public RpsLogic(Random random)
{
this.random = random;
UserData = new Rps();
}
/// <summary>
///
/// </summary>
private void SetPlace()
{
Place = Rps.Descendants(FDefaultNamespace + "NumeroLoteSJC").Count() > 0 ? "SJC" : String.Empty;
}
static void Main(string[] args)
{
WriteLine("hw3#8 - Patrick Barnes");
WriteLine("RockPaperScissors");
Rps player = Rps.ROCK;
Rps computer = Rps.ROCK;
int rand = 0;
//------------------- rand
Random ranNumberGenerator = new Random();
rand = ranNumberGenerator.Next(1, 4);
if (rand == 1)
{
computer = Rps.ROCK;
}
else if (rand == 2)
{
computer = Rps.PAPER;
}
else
{
computer = Rps.SCISSOR;
}
//WriteLine("DEBUG comp:" + computer); //DEBUG
//------------------- input
WriteLine("r,p,or s? :");
player = (Rps)(ReadLine())[0];
//WriteLine("DEBUG player:" + player); //DEBUG
WriteLine("Computer picked " + computer);
//------------------- victory
if (computer == player)
{
WriteLine("Tie!");
}
else if (computer == Rps.ROCK)
{
if (player == Rps.PAPER)
{
Write("Player");
}
else
{
Write("Computer");
}
}
else if (computer == Rps.PAPER)
{
if (player == Rps.SCISSOR)
{
Write("Player");
}
else
{
Write("Computer");
}
}
else //computer == Rps.SCISSOR
{
if (player == Rps.ROCK)
{
Write("Player");
}
else
{
Write("Computer");
}
}
WriteLine(" Wins!");
WriteLine("--End--");
}
public static List <Rps> ObterDadosEnvio()
{
List <Rps> rpsCollection = new List <Rps>();
Rps rps = null;
try {
string pathOrigemImportacao = ParametroDAL.GetValor("OrigemImportacaoPath");
DirectoryInfo diretorio = new DirectoryInfo(@pathOrigemImportacao);
FileInfo[] arquivos = diretorio.GetFiles();
if (arquivos.Length != 0)
{
// Busca arquivos do diretorio
foreach (FileInfo file in arquivos)
{
// Somente arquivos TXT/CSV
if ((file.Extension.ToUpper().Equals(".TXT")) || (file.Extension.ToUpper().Equals(".CSV")))
{
string[] lines = System.IO.File.ReadAllLines(file.FullName);
if (lines.Length != 0)
{
string[] linhaCab = lines[0].Split('|');
string[] columns = new string[50];
string[,] values = new string[lines.Length, columns.Length];
// Verifica se o arquivo possui o cabeçalho SISPEC
if ((lines[0].IndexOf("000|") == 0) || (linhaCab.Length == 17))
{
int i = 0;
// Preenche a matriz values com os valores dos campos
foreach (string line in lines)
{
columns = line.Split('|');
int j = 0;
foreach (string field in columns)
{
values[i, j] = field;
//Console.WriteLine("\t Line[" + i + "] - Field[" + j + "]: " + field);
j++;
}
i++;
}
rps = new Rps();
//string[] DadosNFPlamedAju = ParametroDAL.GetValor("DadosNFPlamedAju").Split(';');
string[] DadosNFOrigem = ParametroDAL.GetValor("DadosNFOrigem").Split(';');
// Primeira linha --> Dados do Prestador
if ((lines[1].IndexOf("001|") == 0))
{
rps.NumeroLote = RpsDAL.GetUltimoLote();
rps.CpfCnpj = DadosNFOrigem[0];
rps.InscricaoMunicipal = DadosNFOrigem[1];
rps.Quantidade = "1"; // Analisar o arquivo se será 1 ou N lotes por arquivo
rps.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Numero = Convert.ToString(LoteRpsDAL.GetUltimoRPS()); //Sequencial => Controle do banco --> Só precisa ser gerado sequencialmente quando o lote for processado com sucesso
rps.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Serie = DadosNFOrigem[2];
rps.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Tipo = DadosNFOrigem[3];
rps.InfDeclaracaoPrestacaoServico.DataEmissao = DateTime.Now.ToString("yyyy-MM-dd");
rps.InfDeclaracaoPrestacaoServico.Status = DadosNFOrigem[4];
rps.InfDeclaracaoPrestacaoServico.Competencia = rps.InfDeclaracaoPrestacaoServico.DataEmissao;
rps.InfDeclaracaoPrestacaoServico.Prestador.CpfCnpj = rps.CpfCnpj;
rps.InfDeclaracaoPrestacaoServico.Prestador.InscricaoMunicipal = rps.InscricaoMunicipal;
}
// Segunda linha --> Dados do Tomador
if ((lines[2].IndexOf("002|") == 0))
{
rps.InfDeclaracaoPrestacaoServico.Tomador.CpfCnpj = values[2, 1];
rps.InfDeclaracaoPrestacaoServico.Tomador.RazaoSocial = values[2, 3];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Logradouro = values[2, 11];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Numero = values[2, 12];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Bairro = values[2, 8];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.CodigoMunicipio = values[2, 6];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Uf = values[2, 7];
rps.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Cep = values[2, 10];
rps.InfDeclaracaoPrestacaoServico.Tomador.Contato.Telefone = values[2, 5];
rps.InfDeclaracaoPrestacaoServico.Tomador.Contato.Email = values[2, 4].ToLower().TrimEnd();
}
// Terceira linha --> Dados do Serviço
if ((lines[3].IndexOf("005|") == 0))
{
decimal valorServico = Convert.ToDecimal(values[3, 1]) / 100;
rps.InfDeclaracaoPrestacaoServico.Servico.Valores.ValorServicos = Convert.ToString(valorServico).Replace(",", ".");
rps.InfDeclaracaoPrestacaoServico.Servico.IssRetido = DadosNFOrigem[5];
rps.InfDeclaracaoPrestacaoServico.Servico.ItemListaServico = DadosNFOrigem[6];
rps.InfDeclaracaoPrestacaoServico.Servico.CodigoCnae = DadosNFOrigem[7];
rps.InfDeclaracaoPrestacaoServico.Servico.CodigoTributacaoMunicipio = rps.InfDeclaracaoPrestacaoServico.Servico.ItemListaServico;
rps.InfDeclaracaoPrestacaoServico.Servico.Discriminacao = values[3, 18];
// Ir na tabela Regra verificar se há alguma regra estabelecida
RegraTO regraGeral = RegraDAL.GetTodos("*");
if (regraGeral.Regra != null)
{
//string discriminacao = regraGeral.Discriminacao;
rps.InfDeclaracaoPrestacaoServico.Servico.Discriminacao = regraGeral.Discriminacao;
}
RegraTO regra = RegraDAL.GetPorCpfCnpjPrestador(rps.InfDeclaracaoPrestacaoServico.Tomador.CpfCnpj);
if (regra.CpfCnpj_Prestador != null)
{
string discriminacao = regra.Discriminacao;
string[] srt_discriminacao = discriminacao.Split('|');
foreach (string valor in srt_discriminacao)
{
switch (valor)
{
case "DataEmissao":
// Campo crítico
string dtEmissao = GetExpressaoComData(rps.InfDeclaracaoPrestacaoServico.DataEmissao, regra.Expressoes);
discriminacao = discriminacao.Replace(valor, dtEmissao);
break;
case "ValorServicos":
discriminacao = discriminacao.Replace(valor, rps.InfDeclaracaoPrestacaoServico.Servico.Valores.ValorServicos);
break;
case "IssRetido":
discriminacao = discriminacao.Replace(valor, rps.InfDeclaracaoPrestacaoServico.Servico.IssRetido);
break;
case "ItemListaServico":
discriminacao = discriminacao.Replace(valor, rps.InfDeclaracaoPrestacaoServico.Servico.ItemListaServico);
break;
case "CodigoCnae":
discriminacao = discriminacao.Replace(valor, rps.InfDeclaracaoPrestacaoServico.Servico.CodigoCnae);
break;
}
}
rps.InfDeclaracaoPrestacaoServico.Servico.Discriminacao = discriminacao.Replace("|", "");
}
rps.InfDeclaracaoPrestacaoServico.Servico.CodigoMunicipio = DadosNFOrigem[8];
rps.InfDeclaracaoPrestacaoServico.Servico.ExigibilidadeISS = DadosNFOrigem[9];
rps.InfDeclaracaoPrestacaoServico.Servico.MunicipioIncidencia = DadosNFOrigem[10];
}
rps.InfDeclaracaoPrestacaoServico.OptanteSimplesNacional = DadosNFOrigem[11];
rps.InfDeclaracaoPrestacaoServico.IncentivoFiscal = DadosNFOrigem[12];
rpsCollection.Add(rps);
}
}
else
{
Console.WriteLine("Conteúdo de arquivo no formato inválido (layout inválido).");
}
}
else
{
Console.WriteLine("Arquivo no formato inválido (tipo inválido).");
}
nomeArquivo = file.Name.Split('.')[0];
}
}
else
{
Console.WriteLine("Nenhum arquivo para importação.");
}
} catch (Exception e) {
Console.WriteLine(e.Message);
}
return(rpsCollection);
}
private void SalvarLote(Rps dados, int count, int seq)
{
try
{
// Inserindo informacoes na tabela LoteRPS
LoteRpsTO loteRpsTo = new LoteRpsTO();
loteRpsTo.NumeroLote = dados.NumeroLote;
loteRpsTo.CpfCnpj = dados.CpfCnpj;
loteRpsTo.InscricaoMunicipal = dados.InscricaoMunicipal;
loteRpsTo.Quantidade = count;
int?IdLote = LoteRpsDAL.Insert(loteRpsTo);
RpsTO rps = new RpsTO();
rps.IdLoteRps = IdLote;
rps.Numero = Convert.ToInt32(dados.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Numero);
rps.Serie = dados.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Serie;
rps.Tipo = Convert.ToInt32(dados.InfDeclaracaoPrestacaoServico.IdentificacaoRps.Tipo);
rps.DataEmissao = dados.InfDeclaracaoPrestacaoServico.DataEmissao;
rps.Status = 1; //Identificar
rps.Competencia = rps.DataEmissao;
rps.ValorServico = dados.InfDeclaracaoPrestacaoServico.Servico.Valores.ValorServicos.Replace(".", ",");
rps.ISSRetido = dados.InfDeclaracaoPrestacaoServico.Servico.IssRetido;
rps.ItemListaServico = dados.InfDeclaracaoPrestacaoServico.Servico.ItemListaServico;
rps.CodigoCnae = dados.InfDeclaracaoPrestacaoServico.Servico.CodigoCnae;
rps.CodigoTributacaoMunicipio = dados.InfDeclaracaoPrestacaoServico.Servico.CodigoTributacaoMunicipio;
rps.Discriminacao = dados.InfDeclaracaoPrestacaoServico.Servico.Discriminacao;
rps.CodigoMunicipio = dados.InfDeclaracaoPrestacaoServico.Servico.CodigoMunicipio;
rps.ExigibilidadeISS = Convert.ToInt16(dados.InfDeclaracaoPrestacaoServico.Servico.ExigibilidadeISS);
rps.MunicipioIncidencia = dados.InfDeclaracaoPrestacaoServico.Servico.MunicipioIncidencia;
rps.CpfCnpj_Prestador = dados.InfDeclaracaoPrestacaoServico.Prestador.CpfCnpj;
/*
* //Obter CNPJ do prestador, verificar na tabela se existe
* PrestadorTO prestador = new PrestadorTO();
* prestador.CpfCnpj_Prestador = dados.InfDeclaracaoPrestacaoServico.Prestador.CpfCnpj;
* prestador.InscricaoMunicipal = dados.InfDeclaracaoPrestacaoServico.Prestador.InscricaoMunicipal;
*
* //Obter CNPJ do tomador, verificar na tabela se existe
* TomadorTO tomador = new TomadorTO();
* tomador.CpfCnpj_Tomador = dados.InfDeclaracaoPrestacaoServico.Tomador.CpfCnpj;
* tomador.RazaoSocial = dados.InfDeclaracaoPrestacaoServico.Tomador.RazaoSocial;
* tomador.Endereco = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Logradouro;
* tomador.Numero = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Numero;
* tomador.Bairro = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Bairro;
* tomador.CodigoMunicipio = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.CodigoMunicipio;
* tomador.Uf = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Uf;
* tomador.Cep = dados.InfDeclaracaoPrestacaoServico.Tomador.Endereco.Cep;
* tomador.Telefone = dados.InfDeclaracaoPrestacaoServico.Tomador.Contato.Telefone;
* tomador.Email = dados.InfDeclaracaoPrestacaoServico.Tomador.Contato.Email;
*/
rps.CpfCnpj_Tomador = dados.InfDeclaracaoPrestacaoServico.Tomador.CpfCnpj;
rps.OptanteSimplesNacional = Convert.ToInt16(dados.InfDeclaracaoPrestacaoServico.OptanteSimplesNacional);
rps.IncentivoFiscal = Convert.ToInt16(dados.InfDeclaracaoPrestacaoServico.IncentivoFiscal);
RpsDAL.Insert(rps);
}
catch (Exception ex)
{
throw;
}
}