void rootgridViewIncoterms_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
{
try
{
GridView view = sender as GridView;
if (CurrentState == ActionsStates.Edit)
{
Incoterm tmpIncoterm = new Incoterm();
object idIncoterm = view.GetRowCellValue(view.FocusedRowHandle, nameof(Incoterm.IdIncoterm));
object description = view.GetRowCellValue(view.FocusedRowHandle, nameof(Incoterm.Description));
object descriptionZh = view.GetRowCellValue(view.FocusedRowHandle, nameof(Incoterm.DescriptionZh).ToString());
tmpIncoterm.IdIncoterm = (idIncoterm ?? string.Empty).ToString();
tmpIncoterm.Description = (description ?? string.Empty).ToString();
tmpIncoterm.DescriptionZh = (descriptionZh ?? string.Empty).ToString();
AddModifiedIncotermsToList(tmpIncoterm);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public Incoterm GetById(int id)
{
var incoterm = new Incoterm();
try
{
using (IDbConnection dbConnection = Connection)
{
string sQuery = @"select
IT_NO as Numero, IT_Code as Code,IT_LIBELLE as Libelle,IT_DATECREATE as DateCreation,
IT_DATEMODIF as DateModification,IT_USER as Utilisateur
from P_INCOTERMS
where IT_NO =@Id ";
dbConnection.Open();
incoterm = dbConnection.Query <Incoterm>(sQuery, new { Id = id }).FirstOrDefault();
}
}
catch (Exception)
{
return(null);
}
return(incoterm);
}
public void QuandoCrioUmIncotermConsigoAcessarAsPropriedades()
{
var incoterm = new Incoterm("001", "INCOTERM 001");
Assert.AreEqual("001", incoterm.Codigo);
Assert.AreEqual("INCOTERM 001", incoterm.Descricao);
}
public void QuandoAlteroADescricaoDoIncotermAPropriedadeFicaComONovoValor()
{
var incoterm = new Incoterm("001", "INCOTERM 001");
incoterm.AtualizaDescricao("INCOTERM 001 atualizado");
Assert.AreEqual("INCOTERM 001 atualizado", incoterm.Descricao);
}
public Incoterm Put([FromBody] Incoterm incoterm)
{
if (ModelState.IsValid)
{
_IncotermService.Update(incoterm);
}
return(incoterm);
}
public Incoterm Post([FromBody] Incoterm incoterm)
{
if (ModelState.IsValid)
{
_IncotermService.Add(incoterm);
}
return(incoterm);
}
public async Task <IHttpActionResult> GetIncoterm(int Id)
{
Incoterm incoterm = await _db.Incoterms.SingleOrDefaultAsync(i => i.Id == Id);
if (incoterm == null)
{
return(NotFound());
}
return(Ok(incoterm));
}
public void QuandoAtualizaoUmaCotacaoAsPropriedadesSaoCriadasCorretamente()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialComCotacaoDoFornecedor();
var condicaoDePagamento = new CondicaoDePagamento("C1", "CONDIÇÃO ALTERAÇÃO");
var incoterm = new Incoterm("I1", "INCOTERM ALTERAÇÃO");
var cotacao = (CotacaoMaterial)processoDeCotacao.FornecedoresParticipantes.First().Cotacao;
cotacao.Atualizar(condicaoDePagamento, incoterm, "INCOTERM ALTERADO");
Assert.AreSame(incoterm, cotacao.Incoterm);
Assert.AreEqual("INCOTERM ALTERADO", cotacao.DescricaoIncoterm);
Assert.AreSame(condicaoDePagamento, cotacao.CondicaoDePagamento);
}
public void QuandoCrioUmaCotacaoAsPropriedadesSaoIniciadasCorretamente()
{
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
var fornecedor = processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
var cotacao = processoDeCotacao.InformarCotacao(fornecedor, condicaoDePagamento, incoterm, "Descrição do Incoterm");
Assert.AreSame(incoterm, cotacao.Incoterm);
Assert.AreEqual("Descrição do Incoterm", cotacao.DescricaoIncoterm);
Assert.AreSame(condicaoDePagamento, cotacao.CondicaoDePagamento);
}
void FillIncorerms(IEnumerable <Incoterm> icts)
{
Assert(!m_owner.InvokeRequired);
var emptyICT = new Incoterm(0, AppText.UNSPECIFIED);
m_owner.m_cbIncoterm.Items.Clear();
m_owner.m_cbIncoterm.Items.Add(emptyICT);
m_owner.m_cbIncoterm.Items.AddRange(icts.ToArray());
m_owner.m_cbIncoterm.DisplayMember = "Name";
m_owner.m_cbIncoterm.SelectedIndex = 0;
}
private void AtualizarIncoterm(IncotermCadastroVm incotermCadastroVm)
{
Incoterm incoterm = _incotermsConsultados.SingleOrDefault(x => x.Codigo == incotermCadastroVm.Codigo);
if (incoterm != null)
{
incoterm.AtualizaDescricao(incotermCadastroVm.Descricao);
}
else
{
incoterm = new Incoterm(incotermCadastroVm.Codigo, incotermCadastroVm.Descricao);
}
_incoterms.Save(incoterm);
}
public void QuandoPersistoUmIncotermComSucessoConsigoConsultarPosteriormente()
{
UnitOfWorkNh.BeginTransaction();
var incoterm = DefaultObjects.ObtemIncotermPadrao();
UnitOfWorkNh.Session.Save(incoterm);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var incoterms = ObjectFactory.GetInstance <IIncoterms>();
Incoterm incotermConsultado = incoterms.BuscaPeloCodigo(incoterm.Codigo).Single();
Assert.IsNotNull(incotermConsultado);
Assert.AreEqual(incoterm.Codigo, incotermConsultado.Codigo);
Assert.AreEqual(incoterm.Descricao, incotermConsultado.Descricao);
}
Incoterm FindIncoterm(string name)
{
Incoterm ict = null;
List <IDataRow> data;
if (m_importedData.TryGetValue(AppContext.TableManager.Incoterms.ID, out data))
{
ict = data.Cast <Incoterm>().SingleOrDefault(d => string.Compare(d.Name, name, true) == 0);
}
if (ict == null)
{
ict = IncotermNameIndexer.Get(name).SingleOrDefault() as Incoterm;
}
return(ict);
}
Place ParsePlace(int ndxRow, Incoterm curIncoterm, Country curOrigin)
{
string[] row = m_srcData[ndxRow];
int colName = m_colMapping[ColumnKey_t.Place];
string name = AdjustInput(row[colName]);
if (string.IsNullOrWhiteSpace(name))
{
return(EmptyPlace);
}
IEnumerable <Place> places = FindPlace(name);
Place result;
if (places.Count() == 1)
{
result = places.Single();
}
else
{
uint ctryID = 0;
if (curOrigin != null && curIncoterm != null)
{
foreach (string s in m_ictNames)
{
if (string.Compare(curIncoterm.Name, s, true) == 0)
{
ctryID = curOrigin.ID;
break;
}
}
}
result = new Place(AppContext.TableManager.Places.CreateUniqID(), name, ctryID);
Assert(!m_pendingData.ContainsKey(AppContext.TableManager.Places.ID));
m_pendingData[AppContext.TableManager.Places.ID] = result;
}
return(result);
}
public void QuandoAtualizarUmaCotacaoDoProcessoAsPropriedadesSaoAtualizadas()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var cotacao = (CotacaoMaterial)processoDeCotacao.FornecedoresParticipantes.First().Cotacao;
Assert.IsNotNull(cotacao);
Assert.AreSame(condicaoDePagamento, cotacao.CondicaoDePagamento);
Assert.AreSame(incoterm, cotacao.Incoterm);
Assert.AreEqual("Descrição do Incoterm 2", cotacao.DescricaoIncoterm);
}
private void AddModifiedIncotermsToList(Incoterm modifiedIncoterm)
{
try
{
var incoterm = _modifiedIncoterms.FirstOrDefault(a => a.IdIncoterm.Equals(modifiedIncoterm.IdIncoterm));
if (incoterm == null)
{
_modifiedIncoterms.Add(modifiedIncoterm);
}
else
{
incoterm.Description = modifiedIncoterm.Description;
incoterm.DescriptionZh = modifiedIncoterm.DescriptionZh;
}
}
catch (Exception ex)
{
throw ex;
}
}
public void QuandoSelecionaUmFornecedorACotacaoFicaMarcadaComoSelecionadaQuantidadeAdquiridaEIvaSaoPreenchidos()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
var processoCotacaoItem = processoDeCotacao.Itens.First();
var cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, new decimal(150.20), 180, 10, DateTime.Today.AddMonths(1), "obs fornec");
Iva iva = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.Selecionar(new decimal(120.00), iva);
Assert.IsTrue(cotacaoItem.Selecionada);
Assert.AreEqual(new decimal(120.00), cotacaoItem.QuantidadeAdquirida);
Assert.AreEqual(iva.Codigo, cotacaoItem.Iva.Codigo);
}
public Incoterm Add(Incoterm incoterm)
{
try
{
using (IDbConnection dbConnection = Connection)
{
string sQuery = @"INSERT INTO P_INCOTERMS
( IT_Code,IT_LIBELLE,IT_DATECREATE,IT_DATEMODIF,IT_USER
)
VALUES (@Code,@Libelle,@DateCreation,@DateModification,@Utilisateur )";
dbConnection.Open();
dbConnection.Execute(sQuery, incoterm);
}
}
catch (Exception)
{
return(null);
}
return(incoterm);
}
public void QuandoFiltroPorListaDeCodigoTemQueRetornarIncotermsCorrespondenteAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
Incoterm incoterm1 = DefaultObjects.ObtemIncotermPadrao();
Incoterm incoterm2 = DefaultObjects.ObtemIncotermPadrao();
Incoterm incoterm3 = DefaultObjects.ObtemIncotermPadrao();
UnitOfWorkNh.Session.Save(incoterm1);
UnitOfWorkNh.Session.Save(incoterm2);
UnitOfWorkNh.Session.Save(incoterm3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var incoterms = ObjectFactory.GetInstance <IIncoterms>();
IList <Incoterm> incotermsConsultados = incoterms.FiltraPorListaDeCodigos(new[] { incoterm1.Codigo, incoterm2.Codigo }).List();
Assert.AreEqual(2, incotermsConsultados.Count);
Assert.AreEqual(1, incotermsConsultados.Count(x => x.Codigo == incoterm1.Codigo));
Assert.AreEqual(1, incotermsConsultados.Count(x => x.Codigo == incoterm2.Codigo));
}
public Incoterm Update(Incoterm incoterm)
{
try
{
using (IDbConnection dbConnection = Connection)
{
string sQuery = @"update P_INCOTERMS set
IT_Code=@Code,IT_LIBELLE=@Libelle,IT_DATECREATE=@DateCreation,IT_DATEMODIF=@DateModification,IT_USER=@Utilisateur
where IT_NO=@Numero";
dbConnection.Open();
dbConnection.Execute(sQuery, incoterm);
}
}
catch (Exception)
{
return(null);
}
return(incoterm);
}
public void QuandoCrioUmItemDeCotacaoAsPropriedasSaoIniciadasCorretamente()
{
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
var fornecedor = processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
var cotacao = processoDeCotacao.InformarCotacao(fornecedor, condicaoDePagamento, incoterm, "Descrição do Incoterm");
var itemDoProcesso = processoDeCotacao.Itens.First();
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(itemDoProcesso, 110, 5, 80, DateTime.Today.AddMonths(1), "observacoes");
Assert.IsFalse(cotacaoItem.Selecionada);
Assert.IsNull(cotacaoItem.Iva);
Assert.IsNull(cotacaoItem.QuantidadeAdquirida);
Assert.AreEqual(110, cotacaoItem.Preco);
Assert.AreEqual(110, cotacaoItem.PrecoInicial);
Assert.AreEqual(110, cotacaoItem.ValorComImpostos);
Assert.AreEqual(110, cotacaoItem.Custo);
Assert.AreEqual(5, cotacaoItem.Mva);
Assert.AreEqual(80, cotacaoItem.QuantidadeDisponivel);
Assert.AreEqual(DateTime.Today.AddMonths(1), cotacaoItem.PrazoDeEntrega);
Assert.AreEqual("observacoes", cotacaoItem.Observacoes);
}
public int AtualizarCotacao(CotacaoMaterialInformarVm cotacaoInformarVm)
{
try
{
_unitOfWork.BeginTransaction();
var processoDeCotacao = (ProcessoDeCotacaoDeMaterial)_processosDeCotacao.BuscaPorId(cotacaoInformarVm.IdProcessoCotacao).Single();
CondicaoDePagamento condicaoDePagamento = _condicoesDePagamento.BuscaPeloCodigo(cotacaoInformarVm.CodigoCondicaoPagamento);
Incoterm incoterm = _incoterms.BuscaPeloCodigo(cotacaoInformarVm.CodigoIncoterm).Single();
var cotacao = processoDeCotacao.InformarCotacao(cotacaoInformarVm.CodigoFornecedor, condicaoDePagamento, incoterm,
cotacaoInformarVm.DescricaoIncoterm);
_processosDeCotacao.Save(processoDeCotacao);
_unitOfWork.Commit();
return(cotacao.Id);
}
catch (Exception)
{
_unitOfWork.RollBack();
throw;
}
}
public void QuandoAtualizoUmItemDeCotacaoAsPropriedadesSaoAlteradasCorretamente()
{
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
var fornecedor = processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
var cotacao = processoDeCotacao.InformarCotacao(fornecedor, condicaoDePagamento, incoterm, "Descrição do Incoterm");
var itemDoProcesso = processoDeCotacao.Itens.First();
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(itemDoProcesso, 110, 0, 80, DateTime.Today.AddMonths(1), "observacoes");
decimal valorLiquidoInicial = cotacaoItem.Preco;
cotacaoItem.Atualizar(220, 10, 90, DateTime.Today.AddMonths(2), "observacoes alteradas");
Assert.AreEqual(220, cotacaoItem.Preco);
Assert.AreEqual(valorLiquidoInicial, cotacaoItem.PrecoInicial);
Assert.AreEqual(220, cotacaoItem.ValorComImpostos);
Assert.AreEqual(220, cotacaoItem.Custo);
Assert.AreEqual(10, cotacaoItem.Mva);
Assert.AreEqual(DateTime.Today.AddMonths(2), cotacaoItem.PrazoDeEntrega);
Assert.AreEqual(90, cotacaoItem.QuantidadeDisponivel);
Assert.AreEqual("observacoes alteradas", cotacaoItem.Observacoes);
}
Incoterm ParseIncoterm(int ndxRow)
{
string[] row = m_srcData[ndxRow];
int colName = m_colMapping[ColumnKey_t.Incoterm];
string name = AdjustInput(row[colName]);
if (string.IsNullOrWhiteSpace(name))
{
return(EmptyIncoterm);
}
Incoterm ict = FindIncoterm(name);
if (ict == null)
{
ict = new Incoterm(AppContext.TableManager.Incoterms.CreateUniqID(), name);
Assert(m_pendingData.ContainsKey(AppContext.TableManager.Incoterms.ID) == false);
m_pendingData[AppContext.TableManager.Incoterms.ID] = ict;
}
return(ict);
}
public CadastroIncotermTests()
{
_unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
_incotermsMock = new Mock <IIncoterms>(MockBehavior.Strict);
_incotermsMock.Setup(x => x.Save(It.IsAny <Incoterm>())).Callback((Incoterm incoterm) => Assert.IsNotNull(incoterm));
_incotermsMock.Setup(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()))
.Callback((string[] i) =>
{
_incotermRetornoRepositorio = (i.Contains("001")
? new IncotermParaAtualizacao("001", "INCOTERM 001")
: null);
})
.Returns(_incotermsMock.Object);
_incotermsMock.Setup(x => x.List())
.Returns(() =>
{
var retorno = new List <Incoterm>();
if (_incotermRetornoRepositorio != null)
{
retorno.Add(_incotermRetornoRepositorio);
}
return(retorno);
});
_cadastroIncoterm = new CadastroIncoterm(_unitOfWorkMock.Object, _incotermsMock.Object);
_incotermPadrao = new IncotermCadastroVm()
{
Codigo = "001",
Descricao = "INCOTERM 001"
};
_listaIncoterms = new List <IncotermCadastroVm>()
{
_incotermPadrao
};
}
public void QuandoRemoverASelecaoDeUmaCotacaoFicaDesmarcadaESemQuantidade()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
var cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var processoCotacaoItem = processoDeCotacao.Itens.First();
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, new decimal(150.20), 180, 10, DateTime.Today.AddMonths(1), "obs fornec");
Iva iva = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.Selecionar(new decimal(120.00), iva);
Iva ivaAlteracao = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.RemoverSelecao(ivaAlteracao);
Assert.IsFalse(cotacaoItem.Selecionada);
Assert.IsNull(cotacaoItem.QuantidadeAdquirida);
Assert.AreSame(ivaAlteracao, cotacaoItem.Iva);
}
private static void PersistirIncoterm(Incoterm incoterm)
{
PersistirEntidade(incoterm);
}
public AtualizadorDeCotacaoTests()
{
_unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
_processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialComCotacaoDoFornecedor();
_processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback(
(ProcessoDeCotacao processoDeCotacao) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
Assert.IsNotNull(processoDeCotacao);
foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
{
Assert.IsNotNull(fornecedorParticipante);
}
});
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Returns(_processosDeCotacaoMock.Object)
.Callback((int id) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
});
_processosDeCotacaoMock.Setup(x => x.Single())
.Returns(_processoDeCotacao);
_incotermsMock = new Mock <IIncoterms>(MockBehavior.Strict);
_incotermsMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
.Returns(_incotermsMock.Object)
.Callback((string codigo) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
_incotermRetorno = Incoterm.Codigo == codigo ? Incoterm : null;
});
_incotermsMock.Setup(x => x.Single())
.Returns(() => _incotermRetorno);
_condicoesDePagamentoMock = new Mock <ICondicoesDePagamento>(MockBehavior.Strict);
_condicoesDePagamentoMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
.Returns((string codigo) => codigo == CondicaoDePagamento.Codigo ? CondicaoDePagamento : null)
.Callback((string codigo) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
});
_atualizadorDeCotacao = new AtualizadorDeCotacaoDeMaterial(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object, _incotermsMock.Object, _condicoesDePagamentoMock.Object);
_cotacaoAtualizarVm = new CotacaoMaterialInformarVm()
{
IdProcessoCotacao = _processoDeCotacao.Id,
CodigoFornecedor = _processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo,
CodigoCondicaoPagamento = CondicaoDePagamento.Codigo,
CodigoIncoterm = Incoterm.Codigo,
DescricaoIncoterm = "Desc Incoterm",
};
_cotacaoItemAtualizarVm = new CotacaoMaterialItemInformarVm
{
IdProcessoCotacao = _processoDeCotacao.Id,
IdCotacao = 0,
IdProcessoCotacaoItem = _processoDeCotacao.Itens.First().Id,
Preco = 110,
Mva = 0,
QuantidadeDisponivel = 150,
Impostos = new CotacaoImpostosVm
{
IcmsAliquota = 17,
IcmsValor = 12,
IcmsStAliquota = 0,
IcmsStValor = 0,
IpiAliquota = 5,
IpiValor = 4,
PisCofinsAliquota = 3
},
ObservacoesDoFornecedor = "observações do fornecedor",
PrazoDeEntrega = DateTime.Today.AddDays(15).ToShortDateString()
};
}
public Incoterm Add(Incoterm incoterm)
{
_IncotermRepository.Add(incoterm);
return(incoterm);
}
public Incoterm Update(Incoterm incoterm)
{
_IncotermRepository.Update(incoterm);
return(incoterm);
}
