public IActionResult Put(int id, [FromBody] TelefoneViewModel value)
{
value.Id = id;
this._telefoneAppService.Editar <TelefoneViewModel>(ref value);
return(Ok(value.Id));
}
public ConfigurationProfile()
{
Shared.Application.Conversores.Configuracao.Registrar(this);
this.AllowNullCollections = true;
ClienteViewModel.Mapping(this);
ClienteListaViewModel.Mapping(this);
EmailViewModel.Mapping(this);
EnderecoViewModel.Mapping(this);
FornecedorViewModel.Mapping(this);
FornecedorListaViewModel.Mapping(this);
IdentificacaoViewModel.Mapping(this);
IndustriaViewModel.Mapping(this);
LojaViewModel.Mapping(this);
LojaListaViewModel.Mapping(this);
ParametroViewModel.Mapping(this);
RamoViewModel.Mapping(this);
TaraViewModel.Mapping(this);
TelefoneViewModel.Mapping(this);
TipoClienteViewModel.Mapping(this);
TipoIdentificacaoViewModel.Mapping(this);
TipoProdutoViewModel.Mapping(this);
TipoPrecoViewModel.Mapping(this);
UsuarioViewModel.Mapping(this);
UnidadeViewModel.Mapping(this);
MarcaViewModel.Mapping(this);
}
public TelefoneViewModel Update(TelefoneViewModel obj)
{
BeginTransaction();
_telefoneService.Update(Mapper.Map <TelefoneViewModel, Telefone>(obj));
Commit();
return(obj);
}
public ActionResult VerTelefone(Int32 id)
{
// Verifica se tem usuario logado
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
USUARIO usuario = new USUARIO();
if ((USUARIO)Session["UserCredentials"] != null)
{
usuario = (USUARIO)Session["UserCredentials"];
}
else
{
return(RedirectToAction("Login", "ControleAcesso"));
}
TELEFONE item = baseApp.GetItemById(id);
objetoAntes = item;
TelefoneViewModel vm = Mapper.Map <TELEFONE, TelefoneViewModel>(item);
return(View(vm));
}
public void Posso_incluir_telefones_em_um_contato()
{
var controller = new ContatosController(Session);
Mapper.AddProfile <ContatoProfile>();
Mapper.AddProfile <TelefoneProfile>();
var contato = new Contato
{
Apelido = "Apelido",
Nome = "Nome"
};
Session.Store(contato);
Session.SaveChanges();
var viewModel = new TelefoneViewModel
{
Numero = "011981234567",
Operadora = Operadora.Tim
};
controller.AddPhone(contato.Id, viewModel);
Session.SaveChanges();
Assert.That(Session.Load <Contato>(contato.Id).Telefones.Count(),
Is.EqualTo(1));
}
public TelefoneViewModel Atualizar(Guid id, TelefoneViewModel viewModel)
{
var telefone = Mapper.Map <Telefone>(viewModel);
var telefoneVm = Mapper.Map <TelefoneViewModel>(_telefoneRepository.Atualizar(id, telefone));
return(telefoneVm);
}
public ActionResult AdicionarTelefone(TelefoneViewModel model)
{
if (ModelState.IsValid)
{
var telefone = model.Update();
if (telefone != null)
{
telefone.UsuarioId = User.Identity.GetUserId <int>();
db.Telefone.Add(telefone);
db.SaveChanges();
TempData["Alerta"] = "Criado com sucesso";
TempData["Classe"] = "green-alert";
}
else
{
TempData["Alerta"] = "Algo deu errado";
TempData["Classe"] = "yellow-alert";
}
}
else
{
TempData["Alerta"] = "Formulário inválido";
TempData["Classe"] = "yellow-alert";
}
return(RedirectToAction("Index"));
}
public TelefoneViewModel Add(TelefoneViewModel obj)
{
var telefone = Mapper.Map <TelefoneViewModel, Telefone>(obj);
BeginTransaction();
_telefoneService.Add(telefone);
Commit();
return(obj);
}
public bool Atualizar(TelefoneViewModel telefoneViewModel)
{
var Telefone = Mapper.Map <TelefoneViewModel, Telefone>(telefoneViewModel);
BeginTransaction();
_telefoneService.Atualizar(Telefone);
Commit();
return(true);
}
public TelefoneViewModel AdicionarTelefone(TelefoneViewModel telefoneViewModel)
{
var telefone = Mapper.Map <TelefoneViewModel, Telefone>(telefoneViewModel);
BeginTransaction();
_telefoneService.AdicionarTelefone(telefone);
Commit();
return(telefoneViewModel);
}
public TelefoneViewModel AtualizarTelefone(TelefoneViewModel telefoneViewModel)
{
var telefone = Mapper.Map <TelefoneViewModel, Telefone>(telefoneViewModel);
BeginTransaction();
_clienteService.AtualizarTelefone(telefone);
Commit();
return(telefoneViewModel);
}
public TelefoneViewModel AtualizarTelefone(TelefoneViewModel telefoneViewModel)
{
var telefone = _service.AtualizarTelefone(_mapper.Map <Telefone>(telefoneViewModel));
if (telefone.ValidationResult.IsValid)
{
Commit();
}
return(_mapper.Map <TelefoneViewModel>(telefone));
}
public IActionResult Put([FromBody] TelefoneViewModel telefoneViewModel)
{
if (!ModelState.IsValid)
{
return(Response());
}
var retorno = _contatoAppService.AtualizarTelefone(telefoneViewModel);
return(Response(viewModel: retorno));
}
public ActionResult AtualizarTelefone(TelefoneViewModel telefoneViewModel)
{
if (ModelState.IsValid)
{
_clienteApplication.AtualizarTelefone(telefoneViewModel);
string url = Url.Action("ListarTelefones", "Clientes", new { id = telefoneViewModel.ClienteId });
return(Json(new { success = true, url = url }));
}
return(PartialView("_AtualizarTelefone", telefoneViewModel));
}
public ActionResult DeletePhone(int id, TelefoneViewModel telefoneViewModel)
{
var telefone = Mapper.Map <TelefoneViewModel, Telefone>(telefoneViewModel);
var contato = DocumentSession.Load <Contato>(id);
contato.RemoveTelefone(telefone);
TempData["success"] = string.Format("Telefone {0} removido.", telefone);
return(null);
}
public ActionResult InserirTelefone(TelefoneViewModel model, int TipoTelefone, int id)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
return(AdicionarTelefone(model, TipoTelefone, id));
}
catch (ArgumentException)
{
throw new ArgumentException();
}
}
public ActionResult AddPhone(int id, TelefoneViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Edit", new { id }));
}
var contato = DocumentSession.Load <Contato>(id);
var telefone = Mapper.Map <Telefone>(viewModel);
contato.IncluiTelefone(telefone);
TempData["success"] = string.Format("Telefone {0} adicionado.", telefone);
return(View("Edit", Mapper.Map <Contato, ContatoViewModel>(contato)));
}
public ActionResult AdicionarTelefone(TelefoneViewModel model, int TipoTelefone, int id)
{
if (!ModelState.IsValid)
{
return(View(model));
}
Telefone telefone = new Telefone
{
DDD = model.DDD,
TELEFONE = model.TELEFONE,
ID_TIPOTEL = TipoTelefone,
ID_CLIENTE = id
};
_telefoneNegocios.Salvar(telefone);
return(RedirectToAction("InserirTelefone", new RouteValueDictionary(new { Controller = "Telefone", Action = "InserirTelefone" })));
}
public ActionResult IncluirTelefone(TelefoneViewModel vm)
{
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
ViewBag.Cats = new SelectList(baseApp.GetAllCategorias(idAss), "CATE_CD_ID", "CATE_NM_NOME");
if (ModelState.IsValid)
{
try
{
// Executa a operação
TELEFONE item = Mapper.Map <TelefoneViewModel, TELEFONE>(vm);
USUARIO usuarioLogado = (USUARIO)Session["UserCredentials"];
Int32 volta = baseApp.ValidateCreate(item, usuarioLogado);
// Verifica retorno
// Sucesso
listaMaster = new List <TELEFONE>();
Session["ListaTelefone"] = null;
Session["VoltaTelefone"] = 1;
Session["IdTelefoneVolta"] = item.TELE_CD_ID;
Session["Telefone"] = item;
Session["MensTelefone"] = 0;
if ((Int32)Session["VoltaTelefone"] == 2)
{
return(RedirectToAction("MontarTelaTelefoneContato"));
}
return(RedirectToAction("MontarTelaTelefone"));
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
return(View(vm));
}
}
else
{
return(View(vm));
}
}
public TelefoneViewModel SalvarTelefone(TelefoneViewModel view, string userId)
{
var telefones = _ITelefoneServico.ObterTelefoneCliente(view.PessoaFisicaID, view.PessoaJuridicaID,
view.PotenciaisClientesID);
if (telefones.Any(c => c.Ddd == view.DDD && c.Numero == view.numero))
{
var validacaoRetorno = new ValidationResult();
validacaoRetorno.Add(
new ValidationError("Telefone informado ja existe para esse cliente."));
return(new TelefoneViewModel {
ValidationResult = validacaoRetorno
});
}
var telefone =
_ITelefoneServico.SalvarTelefone(new Telefone(view.DDD, view.numero, userId, view.PessoaFisicaID,
view.PessoaJuridicaID, view.TelefonesTiposID, view.PotenciaisClientesID));
return(new TelefoneViewModel(telefone.Id, telefone.ClientePessoaFisicaId, telefone.ClientePessoaJuridicaId,
telefone.Ddd, telefone.Numero, "", telefone.TelefonesTiposId, telefone.PotenciaisClientesId));
}
public ActionResult NovoFone(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var contatoViewModel = _contatoAppService.FindById(id.Value);
if (contatoViewModel == null)
{
return(HttpNotFound());
}
var telefoneViewModel = new TelefoneViewModel
{
ContatoId = contatoViewModel.ContatoId
};
return(View(telefoneViewModel));
}
public ActionResult NovoFone(TelefoneViewModel telefoneViewModel)
{
if (!ModelState.IsValid)
{
return(View(telefoneViewModel));
}
var telefoneRetorno = _contatoAppService.AdicionarTelefone(telefoneViewModel);
if (telefoneRetorno.ValidationResult.IsValid)
{
var contatoViewModel = _contatoAppService.FindById(telefoneViewModel.ContatoId);
return(View("Details", contatoViewModel));
}
telefoneRetorno
.ValidationResult
.Erros
.ForEach(e => ModelState.AddModelError(string.Empty, e.Message));
return(View(telefoneViewModel));
}
public HttpResponseMessage Post(UsuarioViewModel usuarioViewModel)
{
var configuration = new HttpConfiguration();
var request = new System.Net.Http.HttpRequestMessage();
request.Properties[System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey] = configuration;
try
{
var usuario = _usuarioAppService.Adicionar(usuarioViewModel);
var telefoneViewModel = new TelefoneViewModel();
foreach (var telefone in usuario.Telefones)
{
// Adicionando os dados do telefone
telefoneViewModel.Id = Guid.NewGuid();
telefoneViewModel.Numero = telefone.Numero;
telefoneViewModel.Ddd = telefone.Ddd;
telefoneViewModel.UsuarioId = usuario.Id;
// chamanda o serviço para adicionar o telefone
_telefoneAppService.AdicionarTelefone(telefoneViewModel);
// Adicionando dados do telefone para retorno
telefone.Id = telefoneViewModel.Id;
telefone.UsuarioId = telefoneViewModel.UsuarioId;
}
return(request.CreateResponse(HttpStatusCode.OK, usuario));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public ActionResult AdicionarTelefone(int idPessoa, TelefoneViewModel viewModel)
{
try {
using (var client = new WebClient()) {
var telefone = Mapper.Map <TelefoneDTO>(viewModel);
client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
client.UploadString(API.Telefones(idPessoa), "POST", JsonConvert.SerializeObject(telefone));
}
string obj;
using (var client = new WebClient()) {
obj = client.DownloadString(API.Telefones(idPessoa));
}
var telefonesDTO = JsonConvert.DeserializeObject(obj, typeof(List <TelefoneDTO>));
var novaViewModel = Mapper.Map <List <TelefoneViewModel> >(telefonesDTO);
return(PartialView("_Telefones", novaViewModel));
} catch (WebException ex) {
ModelState.AddModelError(string.Empty, ex.Message);
return(RedirectToAction("Index"));
}
}
public ActionResult EditarTelefone(Int32 id)
{
USUARIO usuario = new USUARIO();
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
if ((USUARIO)Session["UserCredentials"] != null)
{
usuario = (USUARIO)Session["UserCredentials"];
// Verfifica permissão
if (usuario.PERFIL.PERF_SG_SIGLA != "ADM")
{
Session["MensTelefone"] = 2;
return(RedirectToAction("MontarTelaTelefone", "Telefone"));
}
}
else
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
// Prepara view
ViewBag.Cats = new SelectList(baseApp.GetAllCategorias(idAss), "CATE_CD_ID", "CATE_NM_NOME");
TELEFONE item = baseApp.GetItemById(id);
objetoAntes = item;
Session["Telefone"] = item;
Session["IdVolta"] = id;
TelefoneViewModel vm = Mapper.Map <TELEFONE, TelefoneViewModel>(item);
return(View(vm));
}
public ActionResult EditarTelefone([Bind(Prefix = "Item2")] TelefoneViewModel model)
{
if (ModelState.IsValid)
{
var telefone = model.Update();
if (telefone != null)
{
if (User.Identity.GetUserId <int>() == telefone.UsuarioId)
{
db.Entry(telefone).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
TempData["Alerta"] = "Atualizado com sucesso";
TempData["Classe"] = "green-alert";
return(RedirectToAction("Index"));
}
else
{
TempData["Alerta"] = "Você não pode executar esta ação";
TempData["Classe"] = "yellow-alert";
return(RedirectToAction("Inicio", "Home"));
}
}
else
{
TempData["Alerta"] = "Algo deu errado";
TempData["Classe"] = "yellow-alert";
return(RedirectToAction("Index"));
}
}
else
{
TempData["Alerta"] = "Formulário Inválido";
TempData["Classe"] = "yellow-alert";
return(RedirectToAction("Index"));
}
}
public ActionResult IncluirTelefone()
{
USUARIO usuario = new USUARIO();
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
if ((USUARIO)Session["UserCredentials"] != null)
{
usuario = (USUARIO)Session["UserCredentials"];
// Verfifica permissão
if (usuario.PERFIL.PERF_SG_SIGLA != "ADM")
{
Session["MensTelefone"] = 2;
return(RedirectToAction("MontarTelaTelefone", "Telefone"));
}
}
else
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
// Prepara listas
ViewBag.Cats = new SelectList(baseApp.GetAllCategorias(idAss), "CATE_CD_ID", "CATE_NM_NOME");
// Prepara view
TELEFONE item = new TELEFONE();
TelefoneViewModel vm = Mapper.Map <TELEFONE, TelefoneViewModel>(item);
vm.ASSI_CD_ID = idAss;
vm.TELE_IN_ATIVO = 1;
return(View(vm));
}
public TelefoneViewModel Salvar(TelefoneViewModel viewModel)
{
throw new NotImplementedException();
}
public Task <TelefoneViewModel> AtualizarTelefone(TelefoneViewModel telefoneView)
{
throw new System.NotImplementedException();
}
public IActionResult Post([FromBody] TelefoneViewModel value)
{
this._telefoneAppService.Adicionar <TelefoneViewModel>(ref value);
return(Ok(value.Id));
}
