protected void BtnSalvar_Click(object sender, EventArgs e)
{
OrdemServicoDAO osDao = new OrdemServicoDAO();
string Data = txtDataSolicitacao.Text;
int Prazo;
int.TryParse(txtPrazoEntrega.Text, out Prazo);
double Total;
double.TryParse(txtTotal.Text, out Total);
string Status = DropDownStatus.SelectedValue;
if ((Data.Equals("") || Prazo.Equals("") || Total.Equals("") || Status.Equals("")))
{
LblResultado.Text = "Dados estão inseridos de forma incorreta!!";
}
else
{
OrdemServico os = osDao.Inserir(new OrdemServico()
{
DataSolicitacao = Data,
PrazoEntrega = Prazo,
Total = Total,
Status = Status
});
if (os != null)
{
LblResultado.Text = "Inserido";
//Session["cliente"] = cliente;
//Response.Redirect("~/vwEndereco.aspx");
}
}
}
private void GerarParcelas()
{
for (int numeroParcela = 1; numeroParcela <= Prazo.ToInt(QuantidadeDeParcelas); numeroParcela++)
{
AdicionarParcela(numeroParcela, CalculadoraDeParcelaFactory.Create(numeroParcela));
}
}
public async Task CadastrarNovo(Prazo prazo, Guid userGuid)
{
var userContextData = _sessionContextDataSingleton.ObterUserContext(userGuid);
prazo.IdResponsavel = userContextData.IdFuncionario;
DateTime agora = DateTime.Now;
prazo.DataCriacao = agora;
if (prazo.SubTarefas != null)
{
foreach (Prazo st in prazo.SubTarefas)
{
st.DataCriacao = agora;
st.IdResponsavel = prazo.IdResponsavel;
}
}
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
prazo.TarefaPai = null;
var newPrazo = new PrazoBD().ConverterDeModelo(prazo);
await dbContext.Prazos.AddAsync(newPrazo);
dbContext.SaveUserGuidForLog(userGuid);
await dbContext.SaveChangesAsync();
}
}
public async Task Atualizar(Prazo prazo, Guid userGuid)
{
var userContextData = _sessionContextDataSingleton.ObterUserContext(userGuid);
prazo.IdResponsavel = userContextData.IdFuncionario;
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
await DeletarParticipantes(prazo.Id);
await DeletaSubTarefas(prazo, dbContext);
var prazoDB = await dbContext.Prazos.FindAsync(prazo.Id);
var prazoAud = new PrazoBD().ConverterDeModelo(prazo);
prazoDB.Atualizar(prazoAud);
dbContext.Set <PrazoBD>().Update(prazoDB);
dbContext.SaveUserGuidForLog(userGuid);
await dbContext.SaveChangesAsync();
if (prazo.SubTarefas != null)
{
foreach (Prazo st in prazo.SubTarefas)
{
if (st.PrecisaAtualizar())
{
await Atualizar(st, userGuid);
}
else
{
await CadastrarNovo(st, userGuid);
}
}
}
}
}
internal Prazo ConverterParaModelo()
{
Prazo prazo = new Prazo
{
Assunto = this.Assunto,
Comentarios = this.Comentarios,
DataCompromisso = this.DataCompromisso,
Participantes = this.Participantes?.Select(part => part.ConverterParaModelo()).ToList(),
DataCriacao = this.DataCriacao,
DataLembrete = this.DataLembrete,
DataLembreteResponsavel = this.DataLembreteResponsavel,
Executor = this.Executor,
Exportado = this.Exportado,
Id = this.Id,
IdCategoria = this.IdCategoria,
IdExecutor = this.IdExecutor,
IdPai = this.IdPai,
IdProcesso = this.IdProcesso,
idProcessoDefinitivo = this.idProcessoDefinitivo,
IdResponsavel = this.IdResponsavel,
IdTituloCobranca = this.IdTituloCobranca,
Local = this.Local,
SituacaoLembrete = this.SituacaoLembrete,
SubTarefas = this.SubTarefas?.Select(sub => sub.ConverterParaModelo()).ToList(),
//TarefaPai = this.TarefaPai?.ConverterParaModelo()
};
return(prazo);
}
internal PrazoBD ConverterDeModelo(Prazo prazo)
{
PrazoBD prazoBD = new PrazoBD
{
Assunto = prazo.Assunto,
Comentarios = prazo.Comentarios,
DataCompromisso = prazo.DataCompromisso,
DataCriacao = prazo.DataCriacao,
DataLembrete = prazo.DataLembrete,
DataLembreteResponsavel = prazo.DataLembreteResponsavel,
Executor = prazo.Executor,
Exportado = prazo.Exportado,
Id = prazo.Id,
IdCategoria = prazo.IdCategoria,
IdExecutor = prazo.IdExecutor,
IdPai = prazo.IdPai,
IdProcesso = prazo.IdProcesso,
idProcessoDefinitivo = prazo.idProcessoDefinitivo,
IdResponsavel = prazo.IdResponsavel,
IdTituloCobranca = prazo.IdTituloCobranca,
Local = prazo.Local,
Participantes = prazo.Participantes?.Select(part => new PrazoParticipanteBD().ConverterDeModelo(part)).ToArray(),
//Processo = new ProcessoBaseBD().ConverterDeModelo(prazo.Processo),
SubTarefas = prazo.SubTarefas?.Select(subPrazo => ConverterDeModelo(subPrazo)).ToArray(),
SituacaoLembrete = prazo.SituacaoLembrete,
// TarefaPai = ConverterDeModelo(prazo.TarefaPai),
};
return(prazoBD);
}
public void Prazo_to_int_nullable(int valor)
{
var prazo = Prazo.FromInt(valor);
int?prazoAsIntNullable = ValueFromInt.ToIntNullable(prazo);
prazoAsIntNullable.Should().Be(prazoAsIntNullable);
}
private bool SalvarPrazo(Prazo prazo)
{
try
{
//caso os campos estiverem vazios
if (txtCondPagamento.Text == "" || txtParcelamento.Text == "")
{
MessageBox.Show("É obrigatório preencher a condição pagamento");
}
else
{
prazo.CondPagamento = txtCondPagamento.Text;
prazo.Parcelamento = Convert.ToInt16(txtParcelamento.Text);
prazoBLL.SalvaPrazo(prazo);
MessageBox.Show("Cadastro feito com sucesso");
MessageBox.Show("Código do prazo: " + prazo.CodCondPagamento);
return(true);
}
}
catch (Exception error)
{
MessageBox.Show("Erro: " + error);
}
return(false);
}
public async Task <PrazoViewModel> ObterPrazo(Guid userGuid, int?prazoId, int?casoId)
{
PrazoViewModel vm = new PrazoViewModel();
Prazo prazo = new Prazo();
if (prazoId.HasValue && prazoId.Value > 0)
{
prazo = await _prazoRepositorio.Obter(prazoId.Value);
}
if (casoId.HasValue && casoId.Value > 0)
{
prazo.IdProcesso = casoId.Value;
}
vm = _mapper.Map <PrazoViewModel>(prazo);
vm.HoraAtividade = prazo.DataCompromisso;
if (prazo.IdProcesso.HasValue && prazo.IdProcesso > 0)
{
ProcessoBase caso = await _processoRepositorio.Obter(prazo.IdProcesso.Value);
vm.Processo = string.IsNullOrEmpty(caso.Titulo) ? "Caso sem título. Cliente: " + caso.ClienteNome : caso.Titulo;
}
int?idTituloPai = null;
if (prazo.IdPai.HasValue && prazo.IdPai.Value > 0)
{
Prazo pai = await _prazoRepositorio.Obter(prazo.IdPai.Value);
idTituloPai = pai.IdTituloCobranca;
}
if (!casoId.HasValue || casoId.Value < 1)
{
try
{
vm.PossiveisClientesDefinitivos = await _clienteService.ListarClientes(userGuid);
}
catch (Exception ex)
{
throw new MemberAccessException("Sessão expirada");
}
}
var taskExecutores = _executorService.ListaPossiveisExecutores(userGuid, Domain.Models.TipoDeTarefaEnum.Prazo);
var taskParticipantes = _profissionalService.ListarProfissionais(userGuid);
var taskCategorias = _categoriaDeProfissioalService.Lista(userGuid);
var taskTitulos = _tituloCobrancaService.ListaAsync(userGuid, Domain.Models.TipoDeTarefaEnum.Prazo, idTituloPai);
await Task.WhenAll(taskExecutores, taskParticipantes, taskCategorias, taskTitulos);
vm.PossiveisExecutores = taskExecutores.Result;
vm.TodosPossiveisExecutores = taskExecutores.Result;
vm.PossiveisParticipantes = taskParticipantes.Result;
vm.PossiveisCategorias = taskCategorias.Result;
vm.PossiveisTitulos = taskTitulos.Result;
return(vm);
}
public void DeletarPrazo(Prazo prazo)
{
Conectar();
command = new MySqlCommand("delete from prazo where codCondicao_pagamento = @codCondPagamento");
command.Parameters.AddWithValue("@codCondPagamento", prazo.CodCondPagamento);
}
public void Prazo_subtract_operator(int valor1, int valor2, int resultado)
{
var prazo1 = Prazo.FromInt(valor1);
var prazo2 = Prazo.FromInt(valor2);
var res = prazo1 - prazo2;
res.Should().Be(resultado);
}
public void SalvaPrazo(Prazo prazo)
{
try
{
prazoDAO.SalvarPrazo(prazo);
}
catch (Exception error)
{
MessageBox.Show("Erro: " + error);
}
}
public async Task PersistirDados(Prazo prazo, Guid userGuid)
{
if (prazo.PrecisaAtualizar())
{
await _prazoRepositorio.Atualizar(prazo, userGuid);
}
else
{
await _prazoRepositorio.CadastrarNovo(prazo, userGuid);
}
}
public async Task SalvaPrazo(PrazoViewModel prazo, Guid userGuid)
{
await VinculaSubTitulosEmSubTarefas(prazo, userGuid);
Prazo prazoDB = _mapper.Map <Prazo>(prazo);
prazoDB.AutoValidacao();
prazoDB.RepassaInformacoesParaSubTarefas();
await PersistirDados(prazoDB, userGuid);
}
public void Somatorio_de_prazo_em_dias_como_int(int valor1, int valor2, int valor3, int resultado)
{
var valores =
new Collection <int>()
{
Prazo.ToInt(new Prazo(valor1)),
Prazo.ToInt(new Prazo(valor2)),
Prazo.ToInt(new Prazo(valor3))
};
valores.Sum().Should().Be(Prazo.ToInt(new Prazo(resultado)));
}
private async Task DeletaSubTarefas(Prazo prazo, CadastroExternoContext dbContext)
{
var idsSubtarefasNaoDeletadas = (from st in prazo.SubTarefas
select st.Id).ToList();
IQueryable <PrazoBD> idsQryObject = dbContext.Prazos.Where(x => x.IdPai == prazo.Id && !idsSubtarefasNaoDeletadas.Contains(x.Id));
List <PrazoBD> parzosADeletar = await idsQryObject.AsNoTracking().ToListAsync();
foreach (PrazoBD prazoADeletar in parzosADeletar)
{
await Deletar(prazoADeletar.Id);
}
}
public async Task MarcarExportado(Prazo prazo, Guid userGuid)
{
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
var commandText = "UPDATE prazo SET exportado = 1, id_processo_definitivo = @idDefinitivo WHERE id = @idPrazo";
foreach (var subPrazo in prazo.SubTarefas)
{
var subPrazoId = new SqlParameter("@idPrazo", subPrazo.Id);
var subIdDefinitivo = new SqlParameter("@idDefinitivo", subPrazo.Processo.IdDefinitivo);
await dbContext.Database.ExecuteSqlCommandAsync(commandText, subPrazoId, subIdDefinitivo);
}
var prazoId = new SqlParameter("@idPrazo", prazo.Id);
var idDefinitivo = new SqlParameter("@idDefinitivo", prazo.Processo.IdDefinitivo);
await dbContext.Database.ExecuteSqlCommandAsync(commandText, prazoId, idDefinitivo);
}
}
public async Task ExportaPrazo(Guid userGuid, PrazoViewModel prazo)
{
ValidaExport(prazo);
await VinculaSubTitulosEmSubTarefas(prazo, userGuid);
Prazo toExport = _mapper.Map <Prazo>(prazo);
toExport.AutoValidacao();
toExport.RepassaInformacoesParaSubTarefas();
var prazosTask = _exportService.ExportarPrazos(userGuid, new List <Prazo>()
{
toExport
}, prazo.IdCasoDefinitivo);
await prazosTask;
}
private void TransformaZerosEmNulosLawOffice(Prazo prazo)
{
if (prazo.Id == 0)
{
prazo.Id = int.MinValue;
}
if (!prazo.IdCategoria.HasValue || prazo.IdCategoria == 0)
{
prazo.IdCategoria = int.MinValue;
}
if (!prazo.IdExecutor.HasValue || prazo.IdExecutor == 0)
{
prazo.IdExecutor = int.MinValue;
}
if (!prazo.IdPai.HasValue || prazo.IdPai == 0)
{
prazo.IdPai = int.MinValue;
}
if (!prazo.IdProcesso.HasValue || prazo.IdProcesso == 0)
{
prazo.IdProcesso = int.MinValue;
}
if (!prazo.idProcessoDefinitivo.HasValue || prazo.idProcessoDefinitivo == 0)
{
prazo.idProcessoDefinitivo = int.MinValue;
}
if (prazo.IdResponsavel == 0)
{
prazo.IdResponsavel = int.MinValue;
}
if (!prazo.IdTituloCobranca.HasValue || prazo.IdTituloCobranca == 0)
{
prazo.IdTituloCobranca = int.MinValue;
}
if (prazo.SubTarefas != null)
{
foreach (Prazo st in prazo.SubTarefas)
{
TransformaZerosEmNulosLawOffice(st);
}
}
}
public int modPrazo(string coluna)
{
using (var db = new InformacoesPlanilhaContext())
{
var busca = db.Prazos.Where(x => x.numeroPrazo == coluna).ToList();
if (busca.Count() == 0)
{
Prazo construtor = new Prazo()
{
numeroPrazo = coluna
};
db.Prazos.Add(construtor);
db.SaveChanges();
busca = db.Prazos.Where(x => x.numeroPrazo == coluna).ToList();
}
return(busca[0].idPrazo);
}
}
//salvar Prazo
public void SalvarPrazo(Prazo prazo)
{
try
{
Conectar();
command = new MySqlCommand("insert into prazo (condicao_pagamento, parcelamento) value (@condicao_pagamento, @parcelamento)", conexao);
command.Parameters.AddWithValue("@condicao_pagamento", prazo.CondPagamento);
command.Parameters.AddWithValue("@parcelamento", prazo.Parcelamento);
command.ExecuteNonQuery();
}
catch (Exception error)
{
throw error;
}
finally
{
Desconectar();
}
}
private void ValidaPrazo(Prazo prazo, ref List <string> errorList, ref bool existePrazoSemAssunto)
{
if (string.IsNullOrEmpty(prazo.Assunto))
{
existePrazoSemAssunto = true;
}
if (prazo.DataCompromisso == DateTime.MinValue)
{
errorList.Add(" O prazo " + prazo.Assunto + " está sem data.");
}
if (!prazo.IdExecutor.HasValue || prazo.IdExecutor < 1)
{
errorList.Add(" O prazo " + prazo.Assunto + " está sem executor.");
}
if (prazo.SubTarefas != null)
{
foreach (Prazo p in prazo.SubTarefas)
{
ValidaPrazo(p, ref errorList, ref existePrazoSemAssunto);
}
}
}
public override string ToString()
{
return($"{Id}, {Titulo}, {Categoria.Descricao}, {Prazo.ToString("dd/MM/yyyy")}");
}
public void Criar_prazo_em_dias_de_int(int valor)
{
var prazo = Prazo.FromInt(valor);
Assert.Equal(new Prazo(valor), prazo);
}
public async Task <Dictionary <Atividade, bool> > ExportarPrazo(Guid userGuid, Prazo prazo, int idProcessoDefinitivo)
{
var retorno = new Dictionary <Atividade, bool>();
var context = _sessionContextData.ObterUserContext(userGuid);
prazo.idProcessoDefinitivo = idProcessoDefinitivo;
prazo.IdResponsavel = context.IdFuncionario;
if (prazo.SubTarefas != null)
{
foreach (Prazo st in prazo.SubTarefas)
{
st.idProcessoDefinitivo = idProcessoDefinitivo;
st.IdResponsavel = context.IdFuncionario;
}
}
Lawoffice.Backend.PrazoService.MPrazoPublicacao prazoLOBackend = new Lawoffice.Backend.PrazoService.MPrazoPublicacao();
try
{
prazoLOBackend = _mapper.Map <Lawoffice.Backend.PrazoService.MPrazoPublicacao>(prazo);
}
catch (Exception ex)
{
//loggar erro
throw;
}
var ws = new Lawoffice.Backend.PrazoService.PrazoPublicacaoServiceSoapClient(soapConfiguration, context.UrlServico + ServicesUrlConstants.PRAZOPUBLICACAO);
Lawoffice.Backend.PrazoService.IncluiRequest incluiR = new Lawoffice.Backend.PrazoService.IncluiRequest(context.ContextHeader, prazoLOBackend);
lock (_lockIncluiPrazo)
{
var taskInclude = ws.IncluiAsync(incluiR);
Task.WaitAll(taskInclude);
retorno.Add(_mapper.Map <Atividade>(prazo), true);
}
return(retorno);
}
private void BtnPrazo_Click(object sender, RoutedEventArgs e)
{
Prazo prazo = new Prazo();
SalvarPrazo(prazo);
}
public void Criar_prazo_em_dias_de_int_negativo(int valor)
{
Assert.Throws <ArgumentOutOfRangeException>(() => Prazo.FromInt(valor));
}
public void Criar_prazo_em_dias_de_int_implicitamente(int valor)
{
Prazo prazo = valor;
Assert.Equal(new Prazo(valor), prazo);
}
public void Prazo_em_dias_para_int(int valor)
{
int prazo = Prazo.ToInt(Prazo.FromInt(valor));
Assert.Equal(valor, prazo);
}
public void Aplicar_percentual_value_from_int_multiply_operator(int valor, decimal percentual, decimal resultado)
{
var res = Percentual.FromDecimal(percentual) * Prazo.FromInt(valor);
res.Should().Be(resultado);
}
