/// <summary>
/// Configura dados do emitente para emissão dos documentos fiscais
/// </summary>
/// <param name="cnpj"></param>
/// <param name="cpf"></param>
/// <param name="xNome"></param>
/// <param name="xFant"></param>
/// <param name="ie">
/// Inscrição Estadual
/// <para>Campo de informação obrigatória nos casos de emissão própria (procEmi = 0, 2 ou 3).</para>
/// <para>
/// A IE deve ser informada apenas com algarismos para destinatários contribuintes do ICMS, sem caracteres de
/// formatação (ponto, barra, hífen, etc.);
/// </para>
/// <para>
/// O literal “ISENTO” deve ser informado apenas para contribuintes do ICMS que são isentos de inscrição no
/// cadastro de contribuintes do ICMS e estejam emitindo NF-e avulsa;
/// </para>
/// </param>
/// <param name="ieSt">
/// Informar a IE do ST da UF de destino da mercadoria, quando houver a retenção do ICMS ST para a UF de
/// destino.
/// </param>
/// <param name="im">
/// Inscrição Municipal
/// <para>
/// Este campo deve ser informado, quando ocorrer a emissão de NF-e conjugada, com prestação de serviços sujeitos
/// ao ISSQN e fornecimento de peças sujeitos ao ICMS.
/// </para>
/// </param>
/// <param name="cnae">
/// CNAE fiscal
/// <para>Este campo deve ser informado quando o campo IM (C19) for informado.</para>
/// </param>
/// <param name="crt"></param>
/// <param name="xLgr"></param>
/// <param name="nro"></param>
/// <param name="xCpl"></param>
/// <param name="xBairro"></param>
/// <param name="cMun">
/// Código do município
/// <para>Código do município (utilizar a tabela do IBGE), informar 9999999 para operações com o exterior.</para>
/// </param>
/// <param name="xMun">Nome do município, informar EXTERIOR para operações com o exterior.</param>
/// <param name="uf"> Sigla da UF, informar EX para operações com o exterior.</param>
/// <param name="cep">
/// Código do CEP
/// <para>Informar os zeros não significativos. (NT 2011/004)</para>
/// </param>
/// <param name="fone">
/// Telefone
/// <para>
/// Preencher com o Código DDD + número do telefone. Nas operações com exterior é permitido informar o código do
/// país + código da localidade + número do telefone (v.2.0)
/// </para>
/// </param>
public void ConfiguraEmitente(string cnpj, string cpf, string xNome, string xFant, string ie, string ieSt, string im, string cnae,
CRT crt, string xLgr, string nro, string xCpl, string xBairro, long cMun, string xMun, string uf, string cep, long?fone)
{
Emitente = new emit
{
CNPJ = cnpj,
CPF = cpf,
xNome = xNome,
xFant = xFant,
IE = ie,
IEST = ieSt,
IM = im,
CNAE = cnae,
CRT = crt,
enderEmit = new enderEmit
{
xLgr = xLgr,
nro = nro,
xCpl = xCpl,
xBairro = xBairro,
cMun = cMun,
xMun = xMun,
UF = uf,
CEP = cep,
fone = fone,
cPais = 1058,
xPais = "BRASIL"
}
};
ValidaEmitente();
}
// Use this for initialization
void Start()
{
planeDistance = DisplayCanvas.planeDistance;
fileCounter = 0;
timeleft = 0.1f;
noiseCRT = SnapShotCamera.GetComponent <CRT>();
foreach (var p in Person)
{
p.SetActive(true);
}
person = Person[0];
personCounter = 0;
RestModel();
isStart = false;
isKeyDown = false;
personPos = person.transform.position;
personRotation = person.transform.rotation;
cameraPos = Camera.main.transform.position;
backgroundPos = Background.transform.position;
LoadBackground();
SetBackground();
screenShot = new Texture2D(SnapShotCamera.targetTexture.width, SnapShotCamera.targetTexture.height, TextureFormat.RGB24, false);
}
protected det GetDetalhe(int i, CRT crt)
{
var det = new det
{
nItem = NFeSelected.NFE_DETALHE[i].NUMERO_ITEM.Value,
prod = GetProduto(i),
imposto = new imposto
{
vTotTrib = decimal.Parse(NFeSelected.NFE_DETALHE[i].NFE_DETALHE_IMPOSTO_ICMS[0].VALOR_ICMS.Value.ToString("N2")),
ICMS = new ICMS
{
TipoICMS = crt == CRT.SimplesNacional ? InformarCSOSN(Csosnicms.Csosn102) : InformarICMS(Csticms.Cst00, i)
},
COFINS = new COFINS {
TipoCOFINS = new COFINSOutr {
CST = CSTCOFINS.cofins99, pCOFINS = 0, vBC = 0, vCOFINS = 0
}
},
PIS = new PIS {
TipoPIS = new PISOutr {
CST = CSTPIS.pis99, pPIS = 0, vBC = 0, vPIS = 0
}
}
}
};
return(det);
}
protected det GetDetalhe(int i, CRT crt)
{
var det = new det
{
nItem = NFeSelected.ListaNfeDetalhe[i].NumeroItem.Value,
prod = GetProduto(i),
imposto = new imposto
{
vTotTrib = decimal.Parse(NFeSelected.ListaNfeDetalhe[i].NfeDetalheImpostoIcms.ValorIcms.Value.ToString("N2")),
ICMS = new ICMS
{
TipoICMS = crt == CRT.SimplesNacional ? InformarCSOSN(Csosnicms.Csosn102) : InformarICMS(Csticms.Cst00, i)
},
COFINS = new COFINS {
TipoCOFINS = new COFINSOutr {
CST = CSTCOFINS.cofins99, pCOFINS = 0, vBC = 0, vCOFINS = 0
}
},
PIS = new PIS {
TipoPIS = new PISOutr {
CST = CSTPIS.pis99, pPIS = 0, vBC = 0, vPIS = 0
}
}
}
};
return(det);
}
public void ObterICMSBasico_ICMS00_Teste(CRT crt, OrigemMercadoria origem, DeterminacaoBaseIcms modBC, object vBC, object pICMS, object vICMS, object pFCP, object vFCP)
{
/** 1) Preparação **/
var icmsGeral = new ICMSGeral()
{
orig = origem,
CST = Csticms.Cst00,
modBC = modBC,
vBC = Convert.ToDecimal(vBC),
pICMS = Convert.ToDecimal(pICMS),
vICMS = Convert.ToDecimal(vICMS),
pFCP = Convert.ToDecimal(pFCP),
vFCP = Convert.ToDecimal(vFCP)
};
/** 2) Execução **/
var tagGerada = icmsGeral.ObterICMSBasico(crt);
/** 2) Veerificação **/
/** 2.1) Garante que o tipo da classe gerada foi correta**/
Assert.IsInstanceOfType(tagGerada, typeof(ICMS00));
/** 2.2) Garante que o conteúdo repassado para as propriedades estejam corretos **/
var tagICMSGerada = (tagGerada as ICMS00);
Assert.AreEqual(origem, tagICMSGerada.orig);
Assert.AreEqual(Csticms.Cst00, tagICMSGerada.CST);
Assert.AreEqual(modBC, tagICMSGerada.modBC);
Assert.AreEqual(Convert.ToDecimal(vBC), tagICMSGerada.vBC);
Assert.AreEqual(Convert.ToDecimal(pICMS), tagICMSGerada.pICMS);
Assert.AreEqual(Convert.ToDecimal(vICMS), tagICMSGerada.vICMS);
Assert.AreEqual(Convert.ToDecimal(pFCP), tagICMSGerada.pFCP);
Assert.AreEqual(Convert.ToDecimal(vFCP), tagICMSGerada.vFCP);
}
public void ObterICMSBasico_CSOSN101_Teste(CRT crt, OrigemMercadoria origem, object pCredSN, object vCredICMSSN)
{
/** 1) Preparação **/
var icmsGeral = new ICMSGeral()
{
orig = origem,
CSOSN = Csosnicms.Csosn101,
pCredSN = Convert.ToDecimal(pCredSN),
vCredICMSSN = Convert.ToDecimal(vCredICMSSN)
};
/** 2) Execução **/
var tagGerada = icmsGeral.ObterICMSBasico(crt);
/** 2) Veerificação **/
/** 2.1) Garante que o tipo da classe gerada foi correta**/
Assert.IsInstanceOfType(tagGerada, typeof(ICMSSN101));
/** 2.2) Garante que o conteúdo repassado para as propriedades estejam corretos **/
var tagICMSGerada = (tagGerada as ICMSSN101);
Assert.AreEqual(origem, tagICMSGerada.orig);
Assert.AreEqual(Csosnicms.Csosn101, tagICMSGerada.CSOSN);
Assert.AreEqual(Convert.ToDecimal(pCredSN), tagICMSGerada.pCredSN);
Assert.AreEqual(Convert.ToDecimal(vCredICMSSN), tagICMSGerada.vCredICMSSN);
}
public static void Main()
{
CRT.printf("%f \n", 1000.2222d);
string text = "The quick brown fox jumps over the lazy dog";
CRT.printf("size = %d : %s", CRT.strlen(text), text);
}
public void Solve_1()
{
var crt1 = new CRT(3, 5);
var crt2 = new CRT(15, 7);
var x1 = crt1.Solve(2, 3);
var x2 = crt2.Solve(x1, 2);
Assert.AreEqual(23, x2);
}
static void Build(ParseResult config)
{
Builder builder = new Builder(config.Build);
BuildApply(builder, builder.WritePatch, builder.WriteDir, config.Patches);
BuildApply(builder, builder.WriteFile, builder.WriteDir, config.Files);
byte[] exported = builder.Export();
File.WriteAllBytes(Path.Combine(basePath, "@-output.bin"), exported);
File.WriteAllBytes(Path.Combine(basePath, "@-output.crt"), CRT.Build(buildSettings, exported));
}
public void Solve_2()
{
var expected = 1_000000000_000000000;
var p1 = 998244353;
var p2 = 1107296257;
var crt = new CRT(p1, p2);
var actual = crt.Solve(expected % p1, expected % p2);
Assert.AreEqual(expected, actual);
}
protected virtual det GetDetalhe(int i, CRT crt, ModeloDocumento modelo)
{
var det = new det
{
nItem = i + 1,
prod = GetProduto(i + 1),
imposto = new imposto
{
vTotTrib = 0.17m,
ICMS = new ICMS
{
TipoICMS =
crt == CRT.SimplesNacional
? InformarCSOSN(Csosnicms.Csosn102)
: InformarICMS(Csticms.Cst00, VersaoServico.ve310)
},
COFINS =
new COFINS
{
TipoCOFINS = new COFINSOutr {
CST = CSTCOFINS.cofins99, pCOFINS = 0, vBC = 0, vCOFINS = 0
}
},
PIS = new PIS {
TipoPIS = new PISOutr {
CST = CSTPIS.pis99, pPIS = 0, vBC = 0, vPIS = 0
}
}
}
};
if (modelo == ModeloDocumento.NFe) //NFCe não aceita grupo "IPI"
{
det.imposto.IPI = new IPI()
{
cEnq = 999,
TipoIPI = new IPITrib()
{
CST = CSTIPI.ipi00, pIPI = 5, vBC = 1, vIPI = 0.05m
}
}
}
;
//det.impostoDevol = new impostoDevol() { IPI = new IPIDevolvido() { vIPIDevol = 10 }, pDevol = 100 };
return(det);
}
private static ICMSBasico ObterIcmsBasico(CRT crt)
{
//Leia os dados de seu banco de dados e em seguida alimente o objeto ICMSGeral, como no exemplo abaixo.
ICMSGeral icmsGeral = new ICMSGeral
{
orig = OrigemMercadoria.OmNacional,
CST = Csticms.Cst00,
modBC = DeterminacaoBaseIcms.DbiValorOperacao,
vBC = 1.1m,
pICMS = 18,
vICMS = 0.20m,
motDesICMS = MotivoDesoneracaoIcms.MdiTaxi
};
return(icmsGeral.ObterICMSBasico(crt));
}
public static string CrtParaString(CRT crt)
{
switch (crt)
{
case CRT.SimplesNacional:
return("Simples Nacional");
case CRT.SimplesNacionalExcessoSublimite:
return("Simples Nacional - subimite excedido");
case CRT.RegimeNormal:
return("Normal");
default:
return("Normal");
}
}
public static string CrtParaString(CRT crt)
{
switch (crt)
{
case CRT.SimplesNacional:
return("Simples Nacional");
case CRT.SimplesNacionalExcessoSublimite:
return("Simples Nacional - subimite excedido");
case CRT.RegimeNormal:
return("Normal");
default:
throw new ArgumentOutOfRangeException(nameof(crt));
}
}
private int ReadInternal(byte[] buffer, ulong size, out ulong bytesWritten)
{
bytesWritten = 0;
if (BodyStream != null)
{
var bufferStream = new MemoryStream(buffer);
long prevPosition = BodyStream.Position;
CRT.CopyStream(BodyStream, bufferStream);
bytesWritten = (ulong)(BodyStream.Position - prevPosition);
if (BodyStream.Position != BodyStream.Length)
{
return((int)StreamState.InProgress);
}
}
return((int)StreamState.Done);
}
public CustomerTable(string nazivTabele)
{
string[,] tabela =
new string[, ] {
{ "Id", "int", "IDENTITY(1,1) PRIMARY KEY" },
{ "FirstName", "varchar(30)", "DEFAULT ''" },
{ "LastName", "varchar(30)", "DEFAULT ''" },
{ "Gender", "varchar(30)", "DEFAULT ''" },
{ "Address", "varchar(30)", "DEFAULT ''" },
{ "City", "varchar(30)", "DEFAULT ''" },
{ "Country", "varchar(30)", "DEFAULT ''" },
{ "Telephone", "varchar(30)", "DEFAULT ''" },
{ "Email", "varchar(30)", "DEFAULT ''" },
{ "Debt", "float", "DEFAULT 0.00" }
};
CRT create = new CRT(tabela, nazivTabele);
}
public void Clear()
{
CNPJ = string.Empty;
IE = string.Empty;
IM = string.Empty;
Razao = string.Empty;
Fantasia = string.Empty;
Fone = string.Empty;
CEP = string.Empty;
Logradouro = string.Empty;
Numero = string.Empty;
Complemento = string.Empty;
Bairro = string.Empty;
CidadeCod = string.Empty;
Cidade = string.Empty;
UF = string.Empty;
CRT = CRT.crtSimplesNacional;
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var a = new long[n + 1];
var b = new long[n + 1];
for (int i = 1; i <= n; i++)
{
var v = Read();
a[i] = v[0];
b[i] = v[1];
}
var ab1 = new FNTT302(1 << 20, p1, g1).Convolution(a, b);
var ab2 = new FNTT302(1 << 20, p2, g2).Convolution(a, b);
var crt = new CRT(p1, p2);
var ab = ab1.Zip(ab2, (x, y) => crt.Solve(x, y)).ToArray();
Console.WriteLine(string.Join("\n", ab[1..]));
// 初期化
void Start()
{
audioSource = GameObject.FindGameObjectWithTag("AudioSource").GetComponent <AudioSource>();
// Animatorコンポーネントを取得する
anim = GetComponent <Animator>();
// CapsuleColliderコンポーネントを取得する（カプセル型コリジョン）
col = GetComponent <BoxCollider>();
rb = GetComponent <Rigidbody>();
//メインカメラを取得する
cameraObject = GameObject.FindWithTag("MainCamera");
// CapsuleColliderコンポーネントのHeight、Centerの初期値を保存する
orgColHight = col.size.y;
orgVectColCenter = col.center;
_CRTcamera = Camera.main.GetComponent <CRT>();
_CRTcamera.enabled = false;
//rb.useGravity = true;
}
static object Solve()
{
var n = int.Parse(Console.ReadLine());
var a = ReadL();
// g^{p-1} == 1
var pg = new long[p - 1];
var pgMap = new long[p];
pg[0] = 1;
for (int i = 1; i < pg.Length; i++)
{
pg[i] = pg[i - 1] * g % p;
pgMap[pg[i]] = i;
}
var r = 0L;
var c = new long[p - 1];
foreach (var x in a)
{
if (x == 0)
{
continue;
}
c[pgMap[x]]++;
r -= x * x % p;
}
var c1 = new FNTT302(1 << 20, p1, g1).Convolution(c, c);
var c2 = new FNTT302(1 << 20, p2, g2).Convolution(c, c);
var crt = new CRT(p1, p2);
var conv = c1.Zip(c2, (x, y) => crt.Solve(x, y)).ToArray();
for (int i = 0; i < conv.Length; i++)
{
r += conv[i] * pg[i % (p - 1)];
}
return(r / 2);
}
public void Convolution()
{
const long p1 = 998244353, g1 = 3;
const long p2 = 1107296257, g2 = 10;
var fntt1 = new FNTT202(8, p1, g1);
var fntt2 = new FNTT202(8, p2, g2);
var a = new long[] { 1000000, 1000000, 1000000 };
var b = new long[] { 1000000, 1000000, 1000000, 1000000 };
var c1 = fntt1.Convolution(a, b);
var c2 = fntt2.Convolution(a, b);
var crt = new CRT(p1, p2);
var c = c1.Zip(c2, (x, y) => crt.Solve(x, y)).ToArray();
var expected = new long[] { 1000000000000, 2000000000000, 3000000000000, 3000000000000, 2000000000000, 1000000000000, 0, 0 };
CollectionAssert.AreEqual(expected, c);
}
public static Task <HttpClientConnection> NewConnection(HttpClientConnectionOptions options)
{
options.Validate();
var bootstrap = new ConnectionBootstrap();
options.ConnectionSetup += (sender, e) => {
if (e.ErrorCode != 0)
{
var message = CRT.ErrorString(e.ErrorCode);
bootstrap.TaskSource.SetException(new WebException(String.Format("Failed to connect: {0}", message)));
}
else
{
bootstrap.TaskSource.SetResult(bootstrap.Connection);
}
};
bootstrap.Connection = new HttpClientConnection(options);
return(bootstrap.TaskSource.Task);
}
public Task <StreamResult> MakeRequest(HttpRequest request, HttpResponseStreamHandler responseHandler)
{
var bootstrap = new StreamBootstrap();
responseHandler.StreamComplete += (sender, e) => {
streams.Remove(bootstrap.Stream);
if (e.ErrorCode != 0)
{
var message = CRT.ErrorString(e.ErrorCode);
bootstrap.TaskSource.SetException(new WebException($"Stream {bootstrap.Stream} failed: {message}"));
}
else
{
bootstrap.TaskSource.SetResult(new StreamResult(e.ErrorCode));
}
};
bootstrap.Stream = new HttpClientStream(this, request, responseHandler);
streams.Add(bootstrap.Stream);
bootstrap.Stream.Activate();
return(bootstrap.TaskSource.Task);
}
protected virtual det GetDetalhe(int i, CRT crt)
{
var det = new det
{
nItem = i + 1,
prod = GetProduto(i + 1),
imposto = new imposto
{
vTotTrib = decimal.Parse("0,17"),
ICMS = new ICMS
{
TipoICMS = crt == CRT.SimplesNacional ? InformarCSOSN(Csosnicms.Csosn102) : InformarICMS(Csticms.Cst00, VersaoServico.ve310)
}
//nfe ,
//nfe COFINS = new COFINS {TipoCOFINS = new COFINSOutr {CST = CSTCOFINS.cofins99, pCOFINS = 0, vBC = 0, vCOFINS = 0}},
//nfePIS = new PIS {TipoPIS = new PISOutr {CST = CSTPIS.pis99, pPIS = 0, vBC = 0, vPIS = 0}},
//nfeIPI = new IPI() { cEnq = "999", TipoIPI = new IPITrib() { CST = CSTIPI.ipi00, pIPI = 5, vBC = 1, vIPI = Decimal.Parse("0,05")} }
}
};
//det.impostoDevol = new impostoDevol() { IPI = new IPIDevolvido() { vIPIDevol = decimal.Parse("10") }, pDevol = decimal.Parse("100") };
return(det);
}
// Use this for initialization
void Start()
{
crtEffect = GetComponent <CRT>();
noiseEffect = GetComponent <NoiseAndGrain>();
aberrationEffect = GetComponent <VignetteAndChromaticAberration>();
}
public static string CrtParaString(CRT crt)
{
switch (crt)
{
case CRT.SimplesNacional:
return "Simples Nacional";
case CRT.SimplesNacionalExcessoSublimite:
return "Simples Nacional - subimite excedido";
case CRT.RegimeNormal:
return "Normal";
default:
throw new ArgumentOutOfRangeException(nameof(crt));
}
}
/// <summary>
/// Obtém um objeto ICMSBasico com base nos dados do objeto ICMSGeral e da CRT informada no parâmetro.
/// Esse método pode devolver, por exemplo, um objeto ICMS00, ICMS10, ICMSSN101, etc.
/// </summary>
/// <param name="crt"></param>
/// <returns></returns>
public ICMSBasico ObterICMSBasico(CRT crt)
{
ICMSBasico icmsBasico;
switch (crt)
{
case CRT.SimplesNacional:
switch (CSOSN)
{
case Csosnicms.Csosn101:
icmsBasico = new ICMSSN101();
break;
case Csosnicms.Csosn102:
case Csosnicms.Csosn103:
case Csosnicms.Csosn300:
case Csosnicms.Csosn400:
icmsBasico = new ICMSSN102();
break;
case Csosnicms.Csosn201:
icmsBasico = new ICMSSN201();
break;
case Csosnicms.Csosn202:
case Csosnicms.Csosn203:
icmsBasico = new ICMSSN202();
break;
case Csosnicms.Csosn500:
icmsBasico = new ICMSSN500();
break;
case Csosnicms.Csosn900:
icmsBasico = new ICMSSN900();
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case CRT.SimplesNacionalExcessoSublimite:
case CRT.RegimeNormal:
switch (CST)
{
case Csticms.Cst00:
icmsBasico = new ICMS00();
break;
case Csticms.Cst10:
icmsBasico = new ICMS10();
break;
case Csticms.CstPart10:
case Csticms.CstPart90:
icmsBasico = new ICMSPart();
break;
case Csticms.Cst20:
icmsBasico = new ICMS20();
break;
case Csticms.Cst30:
icmsBasico = new ICMS30();
break;
case Csticms.Cst40:
case Csticms.Cst41:
case Csticms.Cst50:
icmsBasico = new ICMS40();
break;
case Csticms.CstRep41:
icmsBasico = new ICMSST();
break;
case Csticms.Cst51:
icmsBasico = new ICMS51();
break;
case Csticms.Cst60:
icmsBasico = new ICMS60();
break;
case Csticms.Cst70:
icmsBasico = new ICMS70();
break;
case Csticms.Cst90:
icmsBasico = new ICMS90();
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException("crt", crt, null);
}
icmsBasico.CopiarPropriedades(this);
return(icmsBasico);
}
void Start()
{
crt_ = GetComponent <CRT>();
}
private static det GetDetalhe(int i, CRT crt, ModeloDocumento modelo)
{
det det = new det
{
nItem = i + 1,
prod = GetProduto(i + 1),
imposto = new imposto
{
vTotTrib = 0.17m,
ICMS = new ICMS
{
//Se você já tem os dados de toda a tributação persistida no banco em uma única tabela, utilize a linha comentada abaixo para preencher as tags do ICMS
//TipoICMS = ObterIcmsBasico(crt),
//Caso você resolva utilizar método ObterIcmsBasico(), comente esta proxima linha
TipoICMS =
crt == CRT.SimplesNacional
? InformarCSOSN(Csosnicms.Csosn102)
: InformarICMS(Csticms.Cst00, VersaoServico.Versao310)
},
//ICMSUFDest = new ICMSUFDest()
//{
// pFCPUFDest = 0,
// pICMSInter = 12,
// pICMSInterPart = 0,
// pICMSUFDest = 0,
// vBCUFDest = 0,
// vFCPUFDest = 0,
// vICMSUFDest = 0,
// vICMSUFRemet = 0
//},
COFINS = new COFINS
{
//Se você já tem os dados de toda a tributação persistida no banco em uma única tabela, utilize a linha comentada abaixo para preencher as tags do COFINS
//TipoCOFINS = ObterCofinsBasico(),
//Caso você resolva utilizar método ObterCofinsBasico(), comente esta proxima linha
TipoCOFINS = new COFINSOutr {
CST = CSTCOFINS.cofins99, pCOFINS = 0, vBC = 0, vCOFINS = 0
}
},
PIS = new PIS
{
//Se você já tem os dados de toda a tributação persistida no banco em uma única tabela, utilize a linha comentada abaixo para preencher as tags do PIS
//TipoPIS = ObterPisBasico(),
//Caso você resolva utilizar método ObterPisBasico(), comente esta proxima linha
TipoPIS = new PISOutr {
CST = CSTPIS.pis99, pPIS = 0, vBC = 0, vPIS = 0
}
}
}
};
if (modelo == ModeloDocumento.NFe) //NFCe não aceita grupo "IPI"
{
det.imposto.IPI = new IPI()
{
cEnq = 999,
//Se você já tem os dados de toda a tributação persistida no banco em uma única tabela, utilize a linha comentada abaixo para preencher as tags do IPI
//TipoIPI = ObterIPIBasico(),
//Caso você resolva utilizar método ObterIPIBasico(), comente esta proxima linha
TipoIPI = new IPITrib()
{
CST = CSTIPI.ipi00, pIPI = 5, vBC = 1, vIPI = 0.05m
}
};
}
//det.impostoDevol = new impostoDevol() { IPI = new IPIDevolvido() { vIPIDevol = 10 }, pDevol = 100 };
return(det);
}
