private void buttonEditarDefeito_Click(object sender, EventArgs e)
{
DialogResult rsd = MessageBox.Show("Tem certeza que deseja Editar?", "Confirmar alteração de dados", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (rsd == DialogResult.No)
{
return;
}
//verificar se tem linha selecionado
if (dataGridDefeito.SelectedRows.Count == 0)
{
MessageBox.Show("Nenhum Defeito selecionado!");
return;
}
//Pegar Defeito
Defeito defeitoSelecionado = (dataGridDefeito.SelectedRows[0].DataBoundItem as Defeito);
FrmCadastrarDefeito frmCadastrarDefeito = new FrmCadastrarDefeito(AcaoNaTela.Alterar, defeitoSelecionado);
DialogResult resultado = frmCadastrarDefeito.ShowDialog();
if (resultado == DialogResult.Yes)
{
AtualizarGrid();
}
}
public bool SalvarNovaSolucao(DataGridObject obj)
{
bool statusOk = false;
Defeito d = new Defeito();
d.Causa = obj.Causa;
d.DescricaoDefeito = obj.Sintoma;
d.Peca = obj.Peca;
d.Solucao = obj.Solucao;
DefeitoDAO DAO = new DefeitoDAO();
var idNovoDefeito = DAO.Create(d);
if (idNovoDefeito > 0)
{
EquipamentoHasDefeitoDAO HasDAO = new EquipamentoHasDefeitoDAO();
var gravado = HasDAO.Create(obj.EquipId, idNovoDefeito, "");
if (gravado)
{
statusOk = true;
}
}
return(statusOk);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome")] Defeito defeito)
{
if (id != defeito.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(defeito);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DefeitoExists(defeito.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(defeito));
}
public bool SalvarDefeito(string defeito, string obs, int equipamentoID)
{
bool retorno = false;
DefeitoDAO DAO = new DefeitoDAO();
EquipamentoHasDefeitoDAO DAO_HAS = new EquipamentoHasDefeitoDAO();
Defeito obj = new Defeito();
obj.DescricaoDefeito = defeito;
int defeitoID = DAO.Create(obj);
if (defeitoID > 0 && equipamentoID > 0)
{
DAO_HAS.Create(equipamentoID, defeitoID, obs);
retorno = true;
}
return(retorno);
}
public async Task <IActionResult> Edit(int id, [Bind("DefeitoId,DataDefeito,Observacao,TipoDefeitoId,EquipamentoId")] Defeito defeito)
{
if (id != defeito.DefeitoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(defeito);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DefeitoExists(defeito.DefeitoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EquipamentoId"] = new SelectList(_context.Equipamento, "EquipamentoId", "EquipamentoId", defeito.EquipamentoId);
ViewData["TipoDefeitoId"] = new SelectList(_context.TipoDefeito, "TipoDefeitoId", "Titulo", defeito.TipoDefeitoId);
return(View(defeito));
}
private List <Defeito> executarSelect(string query)
{
List <Defeito> lista = new List <Defeito>();
List <Funcionario> listaFuncionario = new List <Funcionario>();
SqlConnection conn = null;
SqlDataReader reader = select(conn, query);
if (reader != null)
{
while (reader.Read())
{
Defeito d = new Defeito();
d.Codigo = reader.GetInt32(0);
d.Tipo = reader.GetString(1);
d.Id = reader.GetInt32(2);
d.Titulo = reader.GetString(3);
d.Status = reader.GetString(4);
d.PlanejadoPara = reader.GetString(5);
d.DataColeta = reader.GetDateTime(6);
d.EncontradoProjeto = reader.GetString(7);
d.TipoRelato = reader.GetString(8);
d.Resolucao = reader.GetString(9);
d.Pai = reader.GetString(10);
d.Projeto = reader.GetInt32(11);
FuncionarioDAO fDAO = new FuncionarioDAO();
d.Responsavel = fDAO.recuperarFuncionarioInCache(listaFuncionario, reader.GetInt32(12));
lista.Add(d);
}
}
desconectar(conn);
return(lista);
}
public DefeitoColecao ConsultarDefeitoPorID(int ID_DEFEITO)
{
try
{
DefeitoColecao defeitoColecao = new DefeitoColecao();
acessoDadosSqlServer.LimparParamentros();
acessoDadosSqlServer.AdicionarParametros("@ID_DEFEITO", ID_DEFEITO);
DataTable dataTableDefeito = acessoDadosSqlServer.ExecutarConsulta(CommandType.StoredProcedure, "uspDefeitoConsultarPorID");
foreach (DataRow linha in dataTableDefeito.Rows)
{
Defeito defeito = new Defeito();
defeito.ID_DEFEITO = Convert.ToInt32(linha["ID_DEFEITO"]);
defeito.NOME_DEFEITO = Convert.ToString(linha["NOME_DEFEITO"]);
defeito.DESCRIÇÃO = Convert.ToString(linha["DESCRIÇÃO"]);
defeito.VALOR = Convert.ToString(linha["VALOR"]);
defeitoColecao.Add(defeito);
}
return(defeitoColecao);
}
catch (Exception ex)
{
throw new Exception("Não foi possivel consultar o Defeito por Id. Detalhes: " + ex.Message);
}
}
public async Task <IActionResult> Create([Bind("Id,Nome")] Defeito defeito)
{
if (ModelState.IsValid)
{
_context.Add(defeito);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(defeito));
}
public int Create(Defeito defeito)
{
int id = 0;
MySqlConnection conexao = MySQLConn.GetInstancia().GetConexao();
conexao.Open();
MySqlCommand command = new MySqlCommand();
command.Connection = conexao;
command.CommandType = System.Data.CommandType.Text;
if (String.IsNullOrEmpty(defeito.Causa) && String.IsNullOrEmpty(defeito.Solucao) && String.IsNullOrEmpty(defeito.Peca))
{
defeito.Causa = "default";
defeito.Peca = "default";
defeito.Solucao = "default";
}
try
{
command.CommandText = "INSERT INTO defeito (Peca,Solucao,DescricaoDefeito,Causa) VALUES (@Peca,@Solucao,@Descricao,@Causa);";
command.Parameters.AddWithValue("@Peca", defeito.Peca);
command.Parameters.AddWithValue("@Solucao", defeito.Solucao);
command.Parameters.AddWithValue("@Descricao", defeito.DescricaoDefeito);
command.Parameters.AddWithValue("@Causa", defeito.Causa);
command.ExecuteNonQuery();
command.CommandText = "SELECT LAST_INSERT_ID() as id;";
MySqlDataReader dr = command.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
if (dr.HasRows)
{
if (dr.Read())
{
id = Convert.ToInt32(dr["id"]);
}
}
conexao.Close();
}
catch (Exception e)
{
conexao.Close();
throw e;
}
return(id);
}
public async Task <IActionResult> Create([Bind("DefeitoId,DataDefeito,Observacao,TipoDefeitoId,EquipamentoId")] Defeito defeito)
{
if (ModelState.IsValid)
{
_context.Add(defeito);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EquipamentoId"] = new SelectList(_context.Equipamento, "EquipamentoId", "EquipamentoId", defeito.EquipamentoId);
ViewData["TipoDefeitoId"] = new SelectList(_context.TipoDefeito, "TipoDefeitoId", "Titulo", defeito.TipoDefeitoId);
return(View(defeito));
}
public List <T> ListarSolucaoesPorFamilia(Guid linhaComercialId, Defeito defeito)
{
var query = GetQueryExpression <T>(true);
query.Distinct = true;
query.Orders.Add(new OrderExpression("new_name", OrderType.Ascending));
query.AddLink("new_valor_servico", "new_servico_assistencia_tecnicaid", "new_servicoid");
query.LinkEntities[0].LinkCriteria.Conditions.Add(new ConditionExpression("new_linha_unidade_negocioid", ConditionOperator.Equal, linhaComercialId));
if (defeito.Id != Guid.Empty)
{
query.LinkEntities[0].LinkCriteria.Conditions.Add(new ConditionExpression("new_defeitoid", ConditionOperator.Equal, defeito.Id));
}
return((List <T>) this.RetrieveMultiple(query).List);
}
public string Excluir(Defeito defeito)
{
try
{
acessoDadosSqlServer.LimparParamentros();
acessoDadosSqlServer.AdicionarParametros("@ID_DEFEITO", defeito.ID_DEFEITO);
string ID_DEFEITO = acessoDadosSqlServer.ExecutarManipulacao(CommandType.StoredProcedure, "uspDefeitoExcluir").ToString();
return(ID_DEFEITO);
}
catch (Exception ex)
{
return(ex.Message);
}
}
private bool existeDefeito(Defeito item)
{
Dictionary <string, string> param = new Dictionary <string, string>();
param.Add(ItemTrabalho.ID, Convert.ToString(item.Id));
DefeitoDAO iDAO = new DefeitoDAO();
List <Defeito> listaItem = iDAO.recuperar(param);
if (listaItem.Count > 0)
{
return(true);
}
return(false);
}
//Construtor
public FrmCadastrarDefeito(AcaoNaTela acaoNaTela, Defeito defeito)
{
InitializeComponent();
this.StartPosition = FormStartPosition.CenterScreen;
acaoNaTelaSelecionada = acaoNaTela;
if (acaoNaTela == AcaoNaTela.Inserir)
{
this.Text = "Inserir Defeito";
}
if (acaoNaTela == AcaoNaTela.Alterar)
{
//carregar defeitos
this.Text = "Alterar Defeito";
textBoxCodigo.Text = defeito.ID_DEFEITO.ToString();
textBoxCodigo.Enabled = false;
textBoxNomeDefeito.Text = defeito.NOME_DEFEITO;
textBoxDescricaoDefeito.Text = defeito.DESCRIÇÃO;
textBoxValorDefeito.Text = defeito.VALOR;
}
if (acaoNaTela == AcaoNaTela.Consultar)
{
this.Text = "Consultar Defeito";
textBoxCodigo.Text = defeito.ID_DEFEITO.ToString();
textBoxCodigo.Enabled = false;
textBoxNomeDefeito.Text = defeito.NOME_DEFEITO;
textBoxDescricaoDefeito.Text = defeito.DESCRIÇÃO;
textBoxValorDefeito.Text = defeito.VALOR;
//Desabilitar
textBoxNomeDefeito.Enabled = false;
textBoxNomeDefeito.TabStop = false;
textBoxDescricaoDefeito.Enabled = false;
textBoxDescricaoDefeito.TabStop = false;
textBoxValorDefeito.Enabled = false;
textBoxValorDefeito.TabStop = false;
buttonSalvar.Visible = false;
buttonCancelar.Focus();
}
}
public void ListarSolucaoesPorFamilia()
{
LinhaComercial linha = new LinhaComercial();
linha = new LinhaComercial()
{
Id = new Guid("404300a3-64a7-e611-80bd-0050568f3ab2")
};
Defeito defeitoFamilia = new Defeito()
{
Id = new Guid("c477bf9f-63a7-e611-80bd-0050568f3ab2")
};
var solucoes = (new CRM2013.Domain.Servicos.RepositoryService()).Solucao.ListarSolucaoesPorFamilia(linha.Id, defeitoFamilia);
}
private void buttonConsultarDefeito_Click(object sender, EventArgs e)
{
//verificar se tem linha selecionado
if (dataGridDefeito.SelectedRows.Count == 0)
{
MessageBox.Show("Nenhum Defeito selecionado!");
return;
}
//Pegar Defeito
Defeito defeitoSelecionado = (dataGridDefeito.SelectedRows[0].DataBoundItem as Defeito);
FrmCadastrarDefeito frmCadastrarDefeito = new FrmCadastrarDefeito(AcaoNaTela.Consultar, defeitoSelecionado);
frmCadastrarDefeito.ShowDialog();
}
private void executarQuery(List <Defeito> lista, string query)
{
SqlConnection conn = null;
conn = conectar(conn);
for (int i = 0; i < lista.Count; i++)
{
Defeito item = lista[i];
SqlCommand cmd = new SqlCommand(query, conn);
List <SqlParameter> listaParametros = criarListaParametros(item);
foreach (SqlParameter parametro in listaParametros)
{
cmd.Parameters.Add(parametro);
}
cmd.ExecuteNonQuery();
}
desconectar(conn);
}
private List <SqlParameter> criarListaParametros(Defeito d)
{
List <SqlParameter> parametros = new List <SqlParameter>();
parametros.Add(new SqlParameter("codigo", d.Codigo));
parametros.Add(new SqlParameter("tipo", d.Tipo));
parametros.Add(new SqlParameter("id", d.Id));
parametros.Add(new SqlParameter("titulo", d.Titulo));
parametros.Add(new SqlParameter("status", d.Status));
parametros.Add(new SqlParameter("planejadoPara", d.PlanejadoPara));
parametros.Add(new SqlParameter("dataColeta", d.DataColeta));
parametros.Add(new SqlParameter("encontradoProjeto", d.EncontradoProjeto));
parametros.Add(new SqlParameter("tipoRelato", d.TipoRelato));
parametros.Add(new SqlParameter("resolucao", d.Resolucao));
parametros.Add(new SqlParameter("pai", d.Pai));
parametros.Add(new SqlParameter("codigoProjeto", d.Projeto));
parametros.Add(new SqlParameter("responsavel", d.Responsavel.Codigo));
return(parametros);
}
public string Inserir(Defeito defeito)
{
try
{
acessoDadosSqlServer.LimparParamentros();
acessoDadosSqlServer.AdicionarParametros("@NOME_DEFEITO", defeito.NOME_DEFEITO);
acessoDadosSqlServer.AdicionarParametros("@DESCRIÇÃO", defeito.DESCRIÇÃO);
acessoDadosSqlServer.AdicionarParametros("@VALOR", defeito.VALOR);
string ID_DEFEITO = acessoDadosSqlServer.ExecutarManipulacao(CommandType.StoredProcedure, "uspDefeitoInserir").ToString();
return(ID_DEFEITO);
}
catch (Exception exception)
{
return(exception.Message);
}
}
private void buttonExcluirDefeito_Click(object sender, EventArgs e)
{
//verificar se tem linha selecionado
if (dataGridDefeito.SelectedRows.Count == 0)
{
MessageBox.Show("Nenhum Defeito selecionado!");
return;
}
// Pergunta se realmente deseja realizar a ação
DialogResult resultado = MessageBox.Show("Tem certeza que deseja Excluir?", "Confirmar exclusão de dados", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (resultado == DialogResult.No)
{
return;
}
//Pegar cliente
Defeito defeitoSelecionado = (dataGridDefeito.SelectedRows[0].DataBoundItem as Defeito);
//Instancia
DefeitoNegocios defeitoNegocios = new DefeitoNegocios();
//Metodo Excluir
string retorno = defeitoNegocios.Excluir(defeitoSelecionado);
try
{
int ID_DEFEITO = Convert.ToInt32(retorno);
MessageBox.Show("Defeito excluido com sucesso!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
AtualizarGrid();
}
catch
{
MessageBox.Show("Não foi possivel excluir", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void tblDefeito_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
// ... Get the TextBox that was edited.
var element = e.EditingElement as System.Windows.Controls.TextBox;
var text = element.Text;
Defeito item = (Defeito)e.Row.Item;
var coluna = e.Column.DisplayIndex;
// ... See if the text edit should be canceled.
// We cancel if the user typed a question mark.
if (text.Length == 0)
{
e.Cancel = true;
}
else
{
DefeitoDAO iDAO = new DefeitoDAO();
if (coluna < 7)
{
Alerta alerta = new Alerta("Somente as colunas Resolucao e Pai podem ser alteradas");
alerta.Show();
e.Cancel = true;
}
else
{
if (coluna == 9)
{
item.Resolucao = Convert.ToString(text);
}
else if (coluna == 10)
{
item.Pai = Convert.ToString(text);
}
iDAO.atualizar(item.encapsularLista());
}
}
}
public DefeitoColecao DefeitoConsultarPorNome(string NOME_DEFEITO)
{
try
{
//Criar coleção nova de clientes
DefeitoColecao defeitoColecao = new DefeitoColecao();
acessoDadosSqlServer.LimparParamentros();
acessoDadosSqlServer.AdicionarParametros("@NOME_DEFEITO", NOME_DEFEITO);
// TABELA DE DADOS
DataTable dataTableDefeito = acessoDadosSqlServer.ExecutarConsulta(CommandType.StoredProcedure, "uspDefeitoConsultarPorNome");
//Transformar em uma coleção cliente, cada linha do datatable é um cliente
//Linha de Dados
foreach (DataRow linha in dataTableDefeito.Rows)
{
//Criar Cliente, colocar os dados na linha, adicionar ele na coleção
Defeito defeito = new Defeito();
defeito.ID_DEFEITO = Convert.ToInt32(linha["ID_DEFEITO"]);
defeito.NOME_DEFEITO = Convert.ToString(linha["NOME_DEFEITO"]);
defeito.DESCRIÇÃO = Convert.ToString(linha["DESCRIÇÃO"]);
defeito.VALOR = Convert.ToString(linha["VALOR"]);
defeitoColecao.Add(defeito);
}
return(defeitoColecao);
}
catch (Exception ex)
{
throw new Exception("Não foi possivel consultar o Defeito por nome. Detalhes: " + ex.Message);
}
}
// GET: Defeitoes
public ActionResult Index(int idReserva)
{
var defeito = db.Defeitos.FirstOrDefault(a => a.Id_reserva == idReserva);
if (defeito == null)
{
defeito = new Defeito {
Id_reserva = idReserva
};
ViewBag.nomeCarro = db.Veiculos.FirstOrDefault(a =>
a.Id_veiculo == (db.Reservas.FirstOrDefault(m => m.Id_reserva == idReserva).Id_veiculo))
?.Nome_veiculo;
ViewBag.nomeCliente = db.Users.Find((db.Reservas.FirstOrDefault(a => a.Id_reserva == idReserva)?.Id_user)).UserName;
db.Defeitos.Add(defeito);
db.SaveChanges();
ViewBag.txtKilometros = "Introduza os kilometros atuais do carro";
return(View(defeito));
}
//TODO
return(RedirectToAction("Index", "Home"));
}
//INSERIR.......................
private void buttonSalvar_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(textBoxNomeDefeito.Text) || string.IsNullOrEmpty(textBoxDescricaoDefeito.Text) || string.IsNullOrEmpty(textBoxValorDefeito.Text))
{
MessageBox.Show("Campos não preenchidos!");
if (string.IsNullOrEmpty(textBoxNomeDefeito.Text))
{
textBoxNomeDefeito.Focus();
}
else
if (string.IsNullOrEmpty(textBoxDescricaoDefeito.Text))
{
textBoxDescricaoDefeito.Focus();
}
else
if (string.IsNullOrEmpty(textBoxValorDefeito.Text))
{
textBoxValorDefeito.Focus();
}
}
else
{
if (acaoNaTelaSelecionada == AcaoNaTela.Inserir)
{
Defeito defeito = new Defeito();
defeito.NOME_DEFEITO = textBoxNomeDefeito.Text;
defeito.DESCRIÇÃO = textBoxDescricaoDefeito.Text;
defeito.VALOR = textBoxValorDefeito.Text;
DefeitoNegocios defeitoNegocios = new DefeitoNegocios();
DialogResult rsd = MessageBox.Show("Tem certeza que deseja salvar?", "Confirmar dados", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (rsd == DialogResult.No)
{
return;
}
string retorno = defeitoNegocios.Inserir(defeito);
try
{
int ID_DEFEITO = Convert.ToInt32(retorno);
MessageBox.Show("Defeito inserido com sucesso! ID: " + ID_DEFEITO.ToString());
this.DialogResult = DialogResult.Yes;
}
catch
{
MessageBox.Show("Não foi possivel inserir ", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Warning);
this.DialogResult = DialogResult.No;
}
}
//ALTERAR.........................
else
if (acaoNaTelaSelecionada == AcaoNaTela.Alterar)
{
Defeito defeito = new Defeito();
defeito.ID_DEFEITO = Convert.ToInt32(textBoxCodigo.Text);
defeito.NOME_DEFEITO = textBoxNomeDefeito.Text;
defeito.DESCRIÇÃO = textBoxDescricaoDefeito.Text;
defeito.VALOR = textBoxValorDefeito.Text;
DefeitoNegocios defeitoNegocios = new DefeitoNegocios();
DialogResult rsd = MessageBox.Show("Tem certeza que deseja alterar?", "Confirmar alteração de dados", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (rsd == DialogResult.No)
{
return;
}
string retorno = defeitoNegocios.Alterar(defeito);
try
{
int ID_DEFEITO = Convert.ToInt32(retorno);
MessageBox.Show("Defeito/ID: " + ID_DEFEITO.ToString() + " Alterado com sucesso!");
this.DialogResult = DialogResult.Yes;
}
catch
{
MessageBox.Show("Não foi possivel alterar. Detalhes: " + retorno, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.DialogResult = DialogResult.No;
}
}
}
}
public void realizarUpload(String file)
{
string[] lines = System.IO.File.ReadAllLines(file);
if (lines.Length > 1 && Util.validarArquivoDefeito(lines[0]) == true)
{
List <Defeito> listaIncluir = new List <Defeito>();
List <Defeito> listaAtualizar = new List <Defeito>();
List <Funcionario> listaFuncionario = new List <Funcionario>();
List <Projeto> listaProjeto = new List <Projeto>();
for (int i = 1; i < lines.Length; i++)
{
string[] linha = lines[i].Replace("\"", "").Split('\t');
Defeito item = new Defeito();
item.Tipo = linha[0];
item.Id = Convert.ToInt32(linha[1]);
item.Titulo = linha[2];
item.Responsavel = baseWindow.recuperarFuncionarioInCache(listaFuncionario, Convert.ToString(linha[3]));
item.Status = linha[4];
item.PlanejadoPara = linha[5];
item.DataColeta = Convert.ToDateTime(txtData.Text);
item.EncontradoProjeto = Convert.ToString(linha[6]);
item.TipoRelato = Convert.ToString(linha[7]);
item.Resolucao = Convert.ToString(linha[8]);
item.Pai = linha[9].Replace("#", "");
int codigo = Convert.ToInt32(((ComboBoxItem)cmbProjeto.SelectedItem).Tag);
string nome = Convert.ToString(((ComboBoxItem)cmbProjeto.SelectedItem).Content);
Projeto p = baseWindow.recuperarProjetoInCache(listaProjeto, Convert.ToInt32(linha[10]), codigo, nome);
item.Projeto = p.Codigo;
if (!existeDefeito(item))
{
listaIncluir.Add(item);
}
else
{
listaAtualizar.Add(item);
}
}
DefeitoDAO tDAO = new DefeitoDAO();
if (listaIncluir.Count > 0)
{
tDAO.incluir(listaIncluir);
}
if (listaAtualizar.Count > 0)
{
tDAO.atualizarPorId(listaAtualizar);
}
Alerta alerta = new Alerta("Arquivo incluido com sucesso!");
alerta.Show();
preencherLista(new Dictionary <string, string>());
}
else
{
Alerta alerta = new Alerta("Arquivo invalido");
alerta.Show();
}
}
static void adicionar(List <BacklogItem> listaBackLog)
{
// cria laço para que o usuário possa criar quantos cards quiser antes de retornar ao menu principal.
bool parar = false;
while (!parar)
{
// solicita o tipo de item (feature, mudança defeito ou debito tecnico)
Console.Clear();
Console.WriteLine("Qual o tipo desse item? (Feature, Mudança, Defeito ou Débito Técnico)");
Console.WriteLine("");
Console.WriteLine("-> 1 - Feature");
Console.WriteLine("-> 2 - Mudança");
Console.WriteLine("-> 3 - Defeito");
Console.WriteLine("-> 4 - Débito Técnico");
Console.WriteLine("");
Console.Write(">");
string type = Console.ReadLine();
// solitica o título do item.
perguntar("Qual o título desse novo item?");
string titulo = Console.ReadLine();
// solicita a descrição do item.
perguntar("Qual a descrição desse novo item?");
string descricao = Console.ReadLine();
// solicita a estimativa do item. Como deve ser um número inteiro, permite que, caso o usuário erre, ele tente novamente por meio de um laço.
perguntar("Qual a estimativa desse novo item?");
int estimativa = 0;
bool parar2 = false;
while (parar2 == false)
{
string str = Console.ReadLine();
Console.Write(">");
try {
estimativa = Convert.ToInt32(str);
parar2 = true;
} catch (Exception e) {
Console.WriteLine("Coloque um número inteiro!");
}
}
// solicita o status do item. Só que já existe uma lista de status existentes no arquivo status list. O usuário não pode inserir outra. Temos o metodo validar status para isso.
Console.Clear();
Console.WriteLine("Qual o status desse novo item?");
Console.WriteLine("");
Status status = 0;
status = validarStatus(status);
//pede para o usuário inserir atributo especial do backlog item. Por exemplo, um débito técnico precisa de uma justificativa.
// cria o objeto e coloca na lista após definir atributo especial.
if (type == "1")
{
Console.Clear();
perguntar("Qual o critério de aceite dessa nova feature?");
string criterioAceiteStr = Console.ReadLine();
Feature novoItem = new Feature(titulo, descricao, estimativa, status, criterioAceiteStr);
listaBackLog.Add(novoItem);
}
else if (type == "2")
{
perguntar("Qual a feature que terá essa mudança?");
string featureStr = Console.ReadLine();
Mudanca novoItem = new Mudanca(titulo, descricao, estimativa, status, featureStr);
listaBackLog.Add(novoItem);
}
else if (type == "3")
{
perguntar("Qual a reprodução do defeito?");
string reproducaoDefeitoStr = Console.ReadLine();
Defeito novoItem = new Defeito(titulo, descricao, estimativa, status, reproducaoDefeitoStr);
listaBackLog.Add(novoItem);
}
else if (type == "4")
{
perguntar("Qual a justificativa desse debito tecnico?");
string justificativaStr = Console.ReadLine();
DebitoTecnico novoItem = new DebitoTecnico(titulo, descricao, estimativa, status, justificativaStr);
listaBackLog.Add(novoItem);
}
// pergunta se o usuário deseja inserir um novo objeto. Em caso positivo, volta para o início.
Console.Clear();
Console.WriteLine("Selecione a opção desejada:");
Console.WriteLine("");
Console.WriteLine("-> 1 - para voltar ao menu inicial.");
Console.WriteLine("-> 2 - para adicionar um novo item");
Console.WriteLine("");
Console.WriteLine("Digite o comando desejado:");
Console.Write(">");
string comando = Console.ReadLine();
if (comando != "2")
{
parar = true;
}
}
}
public ActionResult Index([Bind(Include = "Id,Id_reserva,DanosExteriores,DanosInteriores")] Defeito defeito, IEnumerable <HttpPostedFileBase> files, string kmFinais)
{
if (ModelState.IsValid)
{
var carro = db.Veiculos.FirstOrDefault(a =>
a.Id_veiculo == (db.Reservas.FirstOrDefault(m => m.Id_reserva == defeito.Id_reserva).Id_veiculo));
var kmEntregues = 0;
try
{
kmEntregues = Int16.Parse(kmFinais);
}
catch (Exception e)
{
ViewBag.txtKilometros = "Kilometros invalidos";
return(View(defeito));
}
if (carro.Kilometros > kmEntregues)
{
ViewBag.txtKilometros = "Kilometros invalidos";
return(View(defeito));
}
else
{
carro.Kilometros = kmEntregues - carro.Kilometros;
db.Entry(carro).State = EntityState.Modified;
db.SaveChanges();
}
var nomeCarro = carro.Nome_veiculo;
string nomeImagem = nomeCarro + "_Veiculo_Defeito_";
var httpPostedFileBases = files.ToList();
foreach (var file in httpPostedFileBases)
{
string auxNomeImagem = nomeImagem;
if (file != null && file.ContentLength > 0)
{
if (httpPostedFileBases[0] == file)
{
auxNomeImagem += "Exterior_";
auxNomeImagem += Path.GetExtension(file.FileName);
file.SaveAs(Path.Combine(Server.MapPath("~/uploads"), auxNomeImagem));
defeito.DanosInteriores = auxNomeImagem;
}
else if (httpPostedFileBases[1] == file)
{
auxNomeImagem += "Interior_";
auxNomeImagem += Path.GetExtension(file.FileName);
file.SaveAs(Path.Combine(Server.MapPath("~/uploads"), auxNomeImagem));
defeito.DanosExteriores = auxNomeImagem;
}
}
}
db.Entry(defeito).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View(defeito));
}
