public void CRUD_Poligono()
{
OrdemDeServico OS = unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsNotNull(OS);
List <PoligonoOS> poligonosOs = unitOfWork.PoligonoOSRepository.Get(po => po.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).ToList();
if (poligonosOs != null && poligonosOs.Count > 0)
{
foreach (PoligonoOS item in poligonosOs)
{
unitOfWork.PoligonoOSRepository.Delete(item);
}
unitOfWork.Save();
}
for (int i = 0; i < 5; i++)
{
unitOfWork.PoligonoOSRepository.Insert(new PoligonoOS()
{
OrdemDeServico = OS, X1 = 007.00, X2 = 007.00, Y1 = 007.00, Y2 = 007.00
});
}
unitOfWork.Save();
OS = unitOfWork.OrdemDeServicoRepository.Get(o => o.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault();
Assert.IsNotNull(OS != null && OS.PoligonosOS.Count > 0);
}
public List <OrdemDeServico> VisualizarAbertos()
{
List <OrdemDeServico> lstOrdemDeServico = new List <OrdemDeServico>();
using (SqlConnection objCnx = new SqlConnection(u.Bd_conexao))
{
using (SqlCommand objCmd = new SqlCommand(strVisualizarAbertos, objCnx))
{
objCnx.Open();
SqlDataReader objDataReader = objCmd.ExecuteReader();
if (objDataReader.HasRows)
{
while (objDataReader.Read())
{
OrdemDeServico objOrdemDeServico = new OrdemDeServico();
objOrdemDeServico.codOs = objDataReader["codOs"].ToString();
objOrdemDeServico.prioridade = objDataReader["prioridade"].ToString();
objOrdemDeServico.dataAbertura = Convert.ToDateTime(objDataReader["dataAbertura"]);
objOrdemDeServico.descricao = objDataReader["descricao"].ToString();
objOrdemDeServico.manutentor = objDataReader["manutentor"].ToString();
lstOrdemDeServico.Add(objOrdemDeServico);
}
objCnx.Close();
}
objCnx.Close();
}
return(lstOrdemDeServico);
}
}
public ActionResult GetPostesByOs(string codOs)
{
IEnumerable <Poste> postes_bd = UnitOfWork.PosteRepository.Get(
p => p.OrdemDeServico.NumeroOS == codOs &&
p.DataExclusao == null /* &&
* p.TipoPoste != TipoPoste.ARVORE_P &&
* p.TipoPoste != TipoPoste.ARVORE_M &&
* p.TipoPoste != TipoPoste.ARVORE_G*/,
includeProperties: "OrdemDeServico,Cidade");
OrdemDeServico Ordem = UnitOfWork.OrdemDeServicoRepository.Get(o => o.NumeroOS == codOs, includeProperties: "Cidade,PoligonosOS").FirstOrDefault();
var Informacao = new
{
IdCidade = Ordem.Cidade.IdCidade,
NomeCidade = Ordem.Cidade.Nome
};
return(Json(new
{
Informacao,
Postes = postes_bd.Count() > 0 ? PostePaginadoView.GenerateByOs(postes_bd) : null,
Limites = new LimitesCidadeView().LimitesByOS(Ordem)
}, JsonRequestBehavior.AllowGet));
}
public List <LimitesCidadeView> LimitesByOS(OrdemDeServico ordem_servico)
{
List <LimitesCidadeView> retorno = new List <LimitesCidadeView>();
if (ordem_servico != null)
{
if (ordem_servico.PoligonosOS.Count > 0)
{
foreach (PoligonoOS poligono in ordem_servico.PoligonosOS)
{
ConverterUtmToLatLon converter = new ConverterUtmToLatLon(ordem_servico.Cidade.Datum, ordem_servico.Cidade.NorteOuSul, ordem_servico.Cidade.Zona);
retorno.Add(new LimitesCidadeView
{
LatitudeA = converter.Convert(poligono.X1, poligono.Y1).Lat,
LongitudeA = converter.Convert(poligono.X1, poligono.Y1).Lon,
LatitudeB = converter.Convert(poligono.X2, poligono.Y2).Lat,
LongitudeB = converter.Convert(poligono.X2, poligono.Y2).Lon,
});
}
}
}
return(retorno);
}
public ActionResult NewPoste(PosteView requestData)
{
Cidade cidade = UnitOfWork.CidadeRepository.Get(c => c.IdCidade == requestData.IdCidade).FirstOrDefault();
if (cidade != null)
{
ConverterLatLonToUtm converter = new ConverterLatLonToUtm(cidade.Datum, cidade.NorteOuSul, cidade.Zona);
UTM utm = converter.Convert(requestData.Latitude, requestData.Longitude);
OrdemDeServico ordemDeServico = UnitOfWork.OrdemDeServicoRepository.Get(or => or.NumeroOS == requestData.IdOrdemServicoTexto).FirstOrDefault();
Poste p = new Poste {
X = utm.X, Y = utm.Y, Cidade = cidade, DataCadastro = DateTime.Now, IdOrdemDeServico = ordemDeServico.IdOrdemDeServico, CodigoGeo = -1
};
UnitOfWork.PosteRepository.Insert(p);
UnitOfWork.Save();
Poste pst = UnitOfWork.PosteRepository.Get(pt => pt.X == p.X && pt.Y == p.Y, includeProperties: "Cidade").FirstOrDefault();
PosteView posteview = new MetodosPosteView().PostetoPosteView(pst);
return(Json(new ResponseView()
{
Status = Status.Found, Result = posteview
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new ResponseView()
{
Status = Status.NotFound, Result = Resources.Messages.Cidade_Not_Found
}, JsonRequestBehavior.AllowGet));
}
}
public ActionResult GetQuadrasByOs(string OrdemServico)
{
OrdemDeServico os = UnitOfWork.OrdemDeServicoRepository.Get(o => o.NumeroOS == OrdemServico, includeProperties: "Cidade").FirstOrDefault();
List <Quadra> quadras = UnitOfWork.QuadrasRepository.Get(q => q.IdOrdemDeServico == os.IdOrdemDeServico).ToList();
List <object> quadrasRetorno = new List <object>();
ConverterUtmToLatLon converter = new ConverterUtmToLatLon(os.Cidade.Datum, os.Cidade.NorteOuSul, os.Cidade.Zona);
foreach (Quadra quadraBD in quadras)
{
LatLon LatiLongA = converter.Convert(quadraBD.X1, quadraBD.Y1);
LatLon LatiLongB = converter.Convert(quadraBD.X2, quadraBD.Y2);
quadrasRetorno.Add(new
{
ID = quadraBD.ID,
LatitudeA = LatiLongA.Lat,
LongitudeA = LatiLongA.Lon,
LatitudeB = LatiLongB.Lat,
LongitudeB = LatiLongB.Lon,
});
}
return(Json(new ResponseView()
{
Status = Status.OK, Result = quadrasRetorno
}, JsonRequestBehavior.AllowGet));
}
public ActionResult GetVaosByOs(string NumeroOrdem)
{
OrdemDeServico os = UnitOfWork.OrdemDeServicoRepository.Get(o => o.NumeroOS == NumeroOrdem, includeProperties: "Cidade").FirstOrDefault();
List <VaoPrimario> vaos = UnitOfWork.VaoPrimarioRepository.Get(v => v.IdOrdemDeServico == os.IdOrdemDeServico).ToList();
return(Json(new MetodosVaoView().VaosToVaosViewByOs(vaos, os), JsonRequestBehavior.AllowGet));
}
public List <PontoEntregaMapa> CoordenadasPontoEntregaOrdem(string NumeroOrdem)
{
List <PontoEntregaMapa> coordenadas = new List <PontoEntregaMapa>();
OrdemDeServico ordem = UnitOfWork.OrdemDeServicoRepository.Get(o => o.NumeroOS == NumeroOrdem, includeProperties: "Cidade").FirstOrDefault();
Cidade cidade = ordem.Cidade;
ConverterUtmToLatLon converter = new ConverterUtmToLatLon(cidade.Datum, cidade.NorteOuSul, cidade.Zona);
List <Poste> postes_ordem = UnitOfWork.PosteRepository.Get(p => p.IdOrdemDeServico == ordem.IdOrdemDeServico && p.DataExclusao == null, includeProperties: "PontoDeEntrega").ToList();
foreach (Poste poste in postes_ordem)
{
foreach (PontoEntrega ponto_entrega in poste.PontoDeEntrega)
{
LatLon LatLonPoste = converter.Convert(poste.X, poste.Y);
LatLon LatLonPontoEntrega = converter.Convert(ponto_entrega.X, ponto_entrega.Y);
coordenadas.Add(new PontoEntregaMapa
{
IdPontoEntrega = ponto_entrega.IdPontoEntrega.ToString(),
ponto_entrega_latitude = LatLonPontoEntrega.Lat,
ponto_entrega_longitude = LatLonPontoEntrega.Lon,
poste_latitude = LatLonPoste.Lat,
poste_longitude = LatLonPoste.Lon,
Image = ImagePontoEntrega(ponto_entrega.ClasseSocial)
});
}
}
return(coordenadas);
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
Pessoa funcionario = (Pessoa)dtaListaFuncionario.SelectedItem;
if (funcionario != null)
{
OrdemDeServico os = OrdemDeServicoDAO.listarOrdemPorFuncionario(funcionario);
if (os == null)
{
PessoaDAO.ExcluirPessoa(funcionario);
MessageBox.Show("Funcionario Removido!");
if (funcionario.Cpf.Equals(this.Funcionario.Cpf))
{
this.Funcionario = null;
frmConfigFuncionario frm = new frmConfigFuncionario(Funcionario);
Close();
}
Listar();
}
else
{
MessageBox.Show("Não é possivel excluir o Cadastro, pois o Funcionario \nja fez uma aprovação de ordem de serviço");
}
}
else
{
MessageBox.Show("Selecione o funcionario que deseja excluir.");
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Endereco,TipoServico,CategoriaServico,DescricaoProblema,Status,DataSolicitacao")] OrdemDeServico ordemDeServico)
{
if (id != ordemDeServico.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ordemDeServico);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrdemDeServicoExists(ordemDeServico.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ordemDeServico));
}
public OrdemDeServico Atualizar(OrdemDeServico os)
{
var entry = Db.Entry(os);
DbSet.Attach(os);
entry.State = EntityState.Modified;
return(os);
}
private void GraveAOrdemDeServico(OrdemDeServico ordemDeServico, FirebirdSql.Data.FirebirdClient.FbTransaction transaction)
{
var sql = $@"INSERT INTO TBORDEMSERVICO (ORDEMCOD, ORDEMITEMCLIENTE, ORDEMDATA)
VALUES ({ordemDeServico.Codigo},{ordemDeServico.Cliente.Codigo},{ordemDeServico.Data})";
_conexao.CrieComando(sql);
_conexao.ExecuteComando();
}
public OrdemDeServico Adicionar(OrdemDeServico os)
{
if (os.NecessitaDeAjuste)
{
var programador = _programadorRepository.ObterPorNome(os.Programador).FirstOrDefault();
_emailService.SendEmail(os, programador);
}
return(_ordemDeServicoRepository.Adicionar(os));
}
public void GraveOrdemDeServico(OrdemDeServico ordemDeServico)
{
using (var conexao = new Conexao())
using (var transaction = conexao.CrieTransacao())
{
GraveAOrdemDeServico(ordemDeServico, transaction);
GraveItensDeOrdemDeServico(ordemDeServico, transaction);
transaction.Commit();
}
}
public async Task <IActionResult> Create([Bind("Id,Endereco,TipoServico,CategoriaServico,DescricaoProblema,Status,DataSolicitacao")] OrdemDeServico ordemDeServico)
{
if (ModelState.IsValid)
{
_context.Add(ordemDeServico);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(ordemDeServico));
}
private OrdemDeServico CrieOrdemDeServico()
{
var ordemDeServico = new OrdemDeServico(inpCodigo.Text.Int());
var itens = bsProdutoServico.DataSource as List <ItemMV>;
foreach (var item in itens)
{
ordemDeServico.AdicioneItem(item.Item);
}
ordemDeServico.Data = inpData.Text;
ordemDeServico.AdicioneCliente(pesquisaDeCliente1.ObtenhaSelecionado());
return(ordemDeServico);
}
public void UP_IP_Poste()
{
OrdemDeServico OS = unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsNotNull(OS);
Poste poste = unitOfWork.PosteRepository.Get(p => p.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault();
Assert.IsNotNull(poste);
IP ip = unitOfWork.IPRepository.Get(i => i.Poste.IdPoste == poste.IdPoste, includeProperties: "Poste").FirstOrDefault();
Assert.IsNotNull(ip);
}
public void CRUD_Ordem_de_servico()
{
Cidade cidade = unitOfWork.CidadeRepository.Get(c => c.Nome == NOME_CIDADE).FirstOrDefault();
Assert.IsNotNull(cidade);
/// Add OS de Teste
OrdemDeServico OS = unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault();
if (OS != null)
{
unitOfWork.OrdemDeServicoRepository.Delete(OS);
unitOfWork.Save();
}
OS = new OrdemDeServico()
{
Cidade = cidade, NumeroOS = NUMOS, DataInicio = DateTime.Now
};
unitOfWork.OrdemDeServicoRepository.Insert(OS);
unitOfWork.Save();
Assert.IsNotNull(unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault());
Usuario us = unitOfWork.UsuarioRepository.Get(u => u.UserLogin == "dev").FirstOrDefault();
Assert.IsNotNull(us);
OS.Usuario = us;
unitOfWork.OrdemDeServicoRepository.Update(OS);
unitOfWork.Save();
OS.Usuario = null;
unitOfWork.OrdemDeServicoRepository.Update(OS);
unitOfWork.Save();
Assert.IsNull(unitOfWork.OrdemDeServicoRepository.Get(u => u.NumeroOS == NUMOS).FirstOrDefault().Usuario);
Cidade cidade2 = unitOfWork.CidadeRepository.Get(c => c.Nome == NOME_CIDADE2).FirstOrDefault();
Assert.IsNotNull(cidade2);
//Atualizando a Cidade
OS = unitOfWork.OrdemDeServicoRepository.Get(u => u.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsNotNull(OS);
OS.Cidade = cidade2;
unitOfWork.OrdemDeServicoRepository.Update(OS);
unitOfWork.Save();
OS = unitOfWork.OrdemDeServicoRepository.Get(u => u.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsTrue(OS.Cidade.IdCidade == cidade2.IdCidade);
}
private void MenuItem_Click_2(object sender, RoutedEventArgs e)
{
OrdemDeServico os = OrdemDeServicoDAO.listarOrdemPorCliente(this.Cliente);
if (os == null)
{
PessoaDAO.ExcluirPessoa(this.Cliente);
MessageBox.Show("Cliente Removido!");
Close();
}
else
{
MessageBox.Show("Não é possivel excluir o Cadastro, pois o Cliente \nja fez a solicitação de ordem de serviço");
}
}
public object GetOSByNum(OrdemDeServico ordemDeServico)
{
string dhCriacao = string.Format("{0:yyyy-MM-dd}", ordemDeServico.DataInicio);
string dhEncerramento = string.Format("{0:yyyy-MM-dd}", ordemDeServico.DataFinal);
return(new {
Situacao = ordemDeServico.Situacao,
DhCriacao = dhCriacao,
DhEncerramento = dhEncerramento,
IdUsuario = ordemDeServico.IdUsuario,
NumPoste = ordemDeServico.Postes.Where(p => p.DataExclusao == null).Count(),
NumPosteFinalizado = ordemDeServico.Postes.Where(p => p.DataExclusao == null && p.Finalizado == true).Count(),
Observacao = ordemDeServico.Observacao,
Cidade = ordemDeServico.Cidade
});
}
public ActionResult Liberar(int id)
{
OrdemDeServico o = oDAO.buscarOrdemProId(id);
Pessoa p = pDAO.BuscarPessoaPorCpf(userManager.GetUserName(User));
o.Funcionario = p;
o.Aprovado = true;
o.Processador.OrdemDeServico = o.OrdemId;
o.PlacaMae.OrdemDeServico = o.OrdemId;
o.PlacaVideo.OrdemDeServico = o.OrdemId;
o.Memoria.OrdemDeServico = o.OrdemId;
o.Hd.OrdemDeServico = o.OrdemId;
o.Ssd.OrdemDeServico = o.OrdemId;
oDAO.AlterarOrdemServico(o);
return(RedirectToAction("IndexAdmim", "OrdemDeServico"));
}
public string setServico(
//Serviço
int clienteId, decimal valorTotal,
//Usuario
int usuarioId, string senha,
//Peca
int pecaId,
//Usinagem
double grande, double medio, double pequeno
)
{
JavaScriptSerializer js = new JavaScriptSerializer();
using (masterEntities1 db = new masterEntities1())
{
OrdemDeServico servico = new OrdemDeServico()
{
clienteId = clienteId,
Cliente = db.Cliente.First(x => x.id.Equals(clienteId)),
valorTotal = valorTotal,
Peca = db.Peca.First(x => x.id.Equals(pecaId)),
Usinagem = new Usinagem()
{
grande = grande,
medio = medio,
pequeno = pequeno,
},
pecaId = pecaId,
Usuario = db.Usuario.First(x => x.id.Equals(usuarioId)),
usuarioId = usuarioId
};
if (servico.Usuario.funcao.Trim().ToLower() != "atendente")
{
return(js.Serialize("Usuario não autorizado!"));
}
try
{
db.OrdemDeServico.Add(servico);
db.SaveChanges();
return(js.Serialize("Success"));
}
catch (Exception e)
{
return(js.Serialize("Erro" + e.InnerException));
}
}
}
public ActionResult NewAnotacao(AnotacaoView requestData)
{
Cidade cidade = UnitOfWork.CidadeRepository.Get(c => c.IdCidade == requestData.IdCidade).FirstOrDefault();
OrdemDeServico ordemDeServico = UnitOfWork.OrdemDeServicoRepository.Get(or => or.NumeroOS == requestData.NumeroOs).FirstOrDefault();
if (cidade != null)
{
ConverterLatLonToUtm converter = new ConverterLatLonToUtm(cidade.Datum, cidade.NorteOuSul, cidade.Zona);
UTM utm = converter.Convert(requestData.X, requestData.Y);
Anotacao anotacao = new Anotacao
{
IdCidade = cidade.IdCidade,
IdOrdemDeServico = ordemDeServico.IdOrdemDeServico,
Descricao = requestData.Descricao,
X = utm.X,
Y = utm.Y
};
UnitOfWork.AnotacaoRepository.Insert(anotacao);
UnitOfWork.Save();
Anotacao anotacaoview = UnitOfWork.AnotacaoRepository.Get(nota => nota.IdAnotacao == anotacao.IdAnotacao).FirstOrDefault();
AnotacaoView AnotacaoView = new AnotacaoPaginadoView().AnotacaToAnotacaoView(anotacaoview);
/* var notas = new
* {
* IdCidade = anotacaoview.IdCidade,
* IdOrdemDeServico = anotacaoview.IdOrdemDeServico,
* Descricao = anotacaoview.Descricao,
* X = anotacaoview.X,
* Y = anotacaoview.Y
* };*/
return(Json(new ResponseView()
{
Status = Status.Found, Result = AnotacaoView
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new ResponseView()
{
Status = Status.NotFound, Result = "Cidade nao Encontrada"
}, JsonRequestBehavior.AllowGet));
}
}
public ActionResult SalvarEdicaoOS(string NumOs, string DhFinal, string IdUsuario, SituacaoOrdemServico situacao, string Observacao)
{
OrdemDeServico OS_BD = UnitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NumOs, includeProperties: "Usuario").FirstOrDefault();
string Resul = "OK";
string MsgErro = "";
#region Alterando Dados Ordem Serviço
if (!DhFinal.Equals(string.Empty))
{
DateTime dhEncerramento = Convert.ToDateTime(DhFinal);
if (OS_BD.DataInicio <= dhEncerramento)
{
OS_BD.DataFinal = dhEncerramento;
}
else
{
Resul = "Erro";
} MsgErro = "Data de Encerramento é menor que a data de Criação.";
}
if (!string.IsNullOrEmpty(IdUsuario))
{
OS_BD.IdUsuario = IdUsuario;
}
OS_BD.Situacao = situacao;
OS_BD.Observacao = Observacao;
#endregion
UnitOfWork.OrdemDeServicoRepository.Update(OS_BD);
UnitOfWork.Save();
OrdemServicoView Os_View = new OrdemServicoView()
{
NumeroOrdemServico = OS_BD.NumeroOS,
Situacao = OS_BD.Situacao,
Colaborador = OS_BD.Usuario != null?OS_BD.Usuario.UserName.ToUpper() : "SEM COLABORADOR"
};
return(Json(new { OS_Return = Os_View, Msg = Resul, ErroMsg = MsgErro }, JsonRequestBehavior.AllowGet));
}
public async Task <RetornoCommands> Handle(IncluirOrdemServicoCommand request, CancellationToken cancellationToken)
{
try
{
var ordemServico = new OrdemDeServico(request.nomeServico, request.descricao, request.tipoGarantia, request.periodo, request.valorServico, new PrestadorServico(request.nomePrestador, request.telefonePrestador, request.cpfPrestador));
await _ordemDeServicoRepository.insert(ordemServico);
return(new RetornoCommands {
mensagens = "Operação realizada com sucesso!"
});
}
catch (Exception ex)
{
return(new RetornoCommands {
mensagens = ex.Message.ToString()
});
}
}
public async Task <IActionResult> Create(OrdemDeServico os, IEnumerable <string> check)
{
if (ModelState.IsValid)
{
foreach (var item in check)
{
os.CheckList += item + ",";
}
os.DataAbertura = DateTime.Now;
_context.Add(os);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
else
{
return(View(os));
}
}
public void Add_IP_Poste()
{
OrdemDeServico OS = unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsNotNull(OS);
Poste poste = unitOfWork.PosteRepository.Get(p => p.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault();
poste.IP.Add(new IP()
{
TipoBraco = "ABC", TipoLuminaria = "DEF", QtdLuminaria = 007, TipoLampada = "Florecente", Potencia = 1000, CodigoGeoBD = 007
});
unitOfWork.PosteRepository.Update(poste);
unitOfWork.Save();
IP ip = unitOfWork.PosteRepository.Get(p => p.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault().IP.FirstOrDefault();
Assert.IsNotNull(ip);
}
public void Add_IMG_Poste()
{
OrdemDeServico OS = unitOfWork.OrdemDeServicoRepository.Get(os => os.NumeroOS == NUMOS).FirstOrDefault();
Assert.IsNotNull(OS);
Poste poste = unitOfWork.PosteRepository.Get(p => p.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault();
poste.Fotos.Add(new FotoPoste()
{
CodigoGeoBD = 007, NumeroFoto = "007COD", Path = "C:\\Users\\mcaraujo\\Desktop\\imgTeste.png", Poste = poste
});
unitOfWork.PosteRepository.Update(poste);
unitOfWork.Save();
FotoPoste fotoPoste = unitOfWork.PosteRepository.Get(p => p.OrdemDeServico.IdOrdemDeServico == OS.IdOrdemDeServico).FirstOrDefault().Fotos.FirstOrDefault();
Assert.IsNotNull(fotoPoste);
}
public ActionResult NovoNoMaps([System.Web.Http.FromBody] DemandaStrandView demandaStrandView)
{
Cidade cidade = UnitOfWork.CidadeRepository.Get(c => c.IdCidade == demandaStrandView.IdCidade).FirstOrDefault();
ConverterLatLonToUtm converter = null;
if (cidade != null)
{
converter = new ConverterLatLonToUtm(cidade.Datum, cidade.NorteOuSul, cidade.Zona);
OrdemDeServico ordemDeServico = UnitOfWork.OrdemDeServicoRepository.Get(or => or.NumeroOS == demandaStrandView.NumeroOs).FirstOrDefault();
double x1 = Double.Parse(demandaStrandView.X1Texto, System.Globalization.CultureInfo.InvariantCulture);
double y1 = Double.Parse(demandaStrandView.Y1Texto, System.Globalization.CultureInfo.InvariantCulture);
double x2 = Double.Parse(demandaStrandView.X2Texto, System.Globalization.CultureInfo.InvariantCulture);
double y2 = Double.Parse(demandaStrandView.Y2Texto, System.Globalization.CultureInfo.InvariantCulture);
UTM utm1 = converter.Convert(x1, y1);
UTM utm2 = converter.Convert(x2, y2);
DemandaStrand demandaStrand = new DemandaStrand
{
IdCidade = demandaStrandView.IdCidade,
IdOrdemDeServico = ordemDeServico.IdOrdemDeServico,
X1 = utm1.X,
Y1 = utm1.Y,
X2 = utm2.X,
Y2 = utm2.Y,
DataInclusao = DateTime.Now
};
UnitOfWork.DemandaStrandRepository.Insert(demandaStrand);
UnitOfWork.Save();
DemandaStrand strand = UnitOfWork.DemandaStrandRepository.Get(d => d.ID == demandaStrand.ID).FirstOrDefault();
return(Json(StrandPaginadoView.GenerateUnico(strand), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { Status = Status.NotFound, Result = "Cidade nao encontrada!" }, JsonRequestBehavior.AllowGet));
}
}
public HttpResponseMessage Get(long IdOrdemDeServico)
{
OrdemDeServico OS = UnitOfWork.OrdemDeServicoRepository.Get(os => os.IdOrdemDeServico == IdOrdemDeServico, includeProperties: "Usuario, Postes").FirstOrDefault();
if (OS != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseApi()
{
Status = Status.Found,
Message = Resources.Messages.Found_Register,
Results = new { IdOrdemDeServico = OS.IdOrdemDeServico, NumeroOS = OS.NumeroOS, DataInicio = OS.DataInicio, DataFinal = OS.DataFinal, Usuario = OS.Usuario.UserName, NumeroDePostes = OS.Postes.Where(p => p.DataExclusao == null).Count() }
}));
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseApi()
{
Status = Status.NotFound, Message = Resources.Messages.Not_Register_Data_Base
}));
}
}
