public void VerificarQuandoGeraException()
{
//arrange
var options = new DbContextOptionsBuilder <CaminhaoContext>()
.UseInMemoryDatabase("CaminhaoContext_" + DateTime.Now.ToFileTimeUtc())
.Options;
var contexto = new CaminhaoContext(options);
var repoCaminhaoModelo = new CaminhaoModeloRepository(contexto);
Caminhao caminhao = new Caminhao("Nome 1", 2020, 2021,
new CaminhaoModelo("FH", true));
var mock = new Mock <ICaminhaoRepository>();
mock.Setup(r => r.Salvar(caminhao, 0)).Throws(new Exception("Erro"));
var repo = mock.Object;
CaminhaoController caminhaoController = new CaminhaoController(
repoCaminhaoModelo,
repo
);
CadastroViewModel cadastroViewModel = new CadastroViewModel();
cadastroViewModel.idCaminhao = 0;
cadastroViewModel.caminhao = caminhao;
//act
var resultado = caminhaoController.Inserir(cadastroViewModel) as RedirectToActionResult;
//assert
Assert.Equal("Error", resultado.ActionName);
}
public async Task <IActionResult> Checkout(Cadastro cadastro)
{
try
{
if (ModelState.IsValid)
{
var viewModel = new CadastroViewModel(cadastro);
await carrinhoService.Checkout(GetUserId(), viewModel);
return(RedirectToAction("Checkout"));
}
return(RedirectToAction("Index", "Cadastro"));
}
catch (BrokenCircuitException e)
{
logger.LogError(e, e.Message);
HandleBrokenCircuitException(carrinhoService);
}
catch (Exception e)
{
logger.LogError(e, e.Message);
HandleException();
}
return(View());
}
public IActionResult Cadastro(CadastroViewModel Cadastro)
{
// Busca o cadastro pelo e-mail e senha
Cadastro cadastroBuscado = repository.BuscarEmalSenha(cadastro.Email, cadastro.Senha);
if (cadastroBuscado == null)
{
return(NotFound("E-mail ou senha inválidos"));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, cadastroBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, cadastroBuscado.Id.ToString()),
new Claim(ClaimTypes.Role, cadastroBuscado.Acesso.ToString())
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("WsTower-chave-autenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "WsTower.WebApi", // emissor do token
audience: "WsTower.WebApi", // destinatário do token
claims: claims,
expires: DateTime.Now.AddHours(2),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
public ActionResult Cadastro(CadastroViewModel model)
{
try
{
ModelState.Remove("Setor");
if (ModelState.IsValid)
{
var u = new Usuario();
u.Nome = model.Nome;
u.Login = model.Login.ToLower();
u.Perfil = model.Perfil;
u.Setor = model.Setor;
u.Senha = model.SenhaConfirm;
u.Ativo = true;
new UsuarioDAL().CadastrarUsuario(u);
TempData["Sucesso"] = true;
TempData["Mensagem"] = $"Usuário {u.Login} cadastrado com sucesso";
return(RedirectToAction("Cadastro", "Usuario"));
}
}
catch (Exception e)
{
TempData["Sucesso"] = false;
TempData["Mensagem"] = "Erro: " + e.Message;
}
return(View(new CadastroViewModel()));
}
public IActionResult Cadastro(CadastroViewModel cvm)
{
try
{
if (cvm.Email == null || cvm.Senha == null || cvm.Telefone == null || cvm.NomeUsuario == null)
{
return(BadRequest("Preencha todos os campos"));
}
else
{
if (_u.BuscarPorEmail(cvm.Email))
{
if (_u.Cadastrar(cvm.NomeUsuario, cvm.Email, cvm.Senha, cvm.Telefone))
{
return(Ok("Usuario cadastrado"));
}
else
{
return(BadRequest("Não foi possivel Realizar o cadastro"));
}
}
else
{
return(BadRequest("Esse email ja existe"));
}
}
}
catch (Exception e)
{
return(BadRequest("Não foi possivel efetuar o cadastro"));
}
}
public IActionResult Cadastro()
{
var viewmodel = new CadastroViewModel();
viewmodel.Mensagem = (string)TempData["msg-cadastro"];
return(View(viewmodel));
}
public async Task <IActionResult> Index()
{
await CheckUserCounterData();
try
{
var usuario = appUserParser.Parse(HttpContext.User);
CadastroViewModel cadastro
= new CadastroViewModel()
{
Bairro = usuario.Bairro,
CEP = usuario.CEP,
Complemento = usuario.Complemento,
Email = usuario.Email,
Endereco = usuario.Endereco,
Municipio = usuario.Municipio,
Nome = usuario.Nome,
Telefone = usuario.Telefone,
UF = usuario.UF
};
return(View(cadastro));
}
catch (Exception e)
{
logger.LogError(e, e.Message);
HandleException();
}
return(View());
}
public JsonResult Versao(CadastroViewModel model)
{
var d = new MarkupDAL();
int versao = d.Versao(model.Codun);
return(Json(versao));
}
//public List<Item> Buscar(string param)
//{
// List<Item> announcements = _context.Items.ToList();
// announcements.Where(m => m.GetType().GetProperties().Any(x => x.GetValue(m, null) != null && x.GetValue(m, null).ToString().Contains(param)));
// return announcements;
//}
private CadastroViewModel ListarCategorias()
{
CadastroViewModel cadastroViewModel = new CadastroViewModel();
cadastroViewModel.Categories = _context.Categories.ToList();
return(cadastroViewModel);
}
public JsonResult MetaMinima(CadastroViewModel model)
{
var listaMetas = RegrasMarkup.Modalidade_MediaMinima_MetaMinima();
var metaMinimaMensal = listaMetas.Where(m => m.ModalidadeMarkup.Equals(model.ModalidadeMarkup)).ToList();
return(Json(metaMinimaMensal));
}
//[HttpPost]
public ActionResult CadastrarUsuarioProfissional(CadastroViewModel novoUsuario)
{
DAOUsuarioProfissional daoUsuarioProfissional = null;
UsuarioProfissional usuarioProfissional = null;
try
{
daoUsuarioProfissional = new DAOUsuarioProfissional();
usuarioProfissional = new UsuarioProfissional();
usuarioProfissional.Nome = novoUsuario.Nome;
usuarioProfissional.Sobrenome = novoUsuario.Sobrenome;
usuarioProfissional.Email = novoUsuario.Email;
usuarioProfissional.Senha = novoUsuario.Senha;
//usuarioProfissional.DataNascimento = novoUsuario.DataNascimento;
//usuarioProfissional.Sexo = novoUsuario.Sexo;
//usuarioProfissional.Perfil = Usuario.TipoPerfil.UsuarioProfissional;
if (daoUsuarioProfissional.IncluirUsuarioProfissional(usuarioProfissional))
{
Session["Usuario"] = usuarioProfissional;
}
return(Json(new
{
info = "redirect",
data = Url.Action("UsuarioProfissional", "Perfil")
}));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Tarefa(CadastroViewModel tarefa)
{
if (ModelState.IsValid)
{
await _tarefa.Cadastrar(
new Tarefa()
{
Area = tarefa.Area,
DataConclusao = tarefa.DataConclusao,
DataConclusaoPrevista = tarefa.DataConclusaoPrevista,
Descricao = tarefa.Descricao,
Status = tarefa.Status,
Responsavel = tarefa.Responsavel,
Origem = tarefa.Origem,
Observacoes = tarefa.Observacoes,
Impacto = tarefa.Impacto,
ContatoId = tarefa.ContatoId
});
TempData["MSGSS1"] = "Cadastro concluído com sucesso!";
return(RedirectToAction("index", "home"));
}
else
{
ViewBag.Contatos = _contato.Listar().Result.Select(a => new SelectListItem(a.Email, a.ContatoId.ToString()));
return(View(tarefa));
}
}
public ActionResult CadastrarUsuarioParticular(CadastroViewModel novoUsuario)
{
DAOUsuarioParticular daoUsuarioParticular = null;
UsuarioParticular usuarioParticular = null;
try
{
daoUsuarioParticular = new DAOUsuarioParticular();
usuarioParticular = new UsuarioParticular();
usuarioParticular.Nome = novoUsuario.Nome;
usuarioParticular.Email = novoUsuario.Email;
usuarioParticular.Senha = novoUsuario.Senha;
if (daoUsuarioParticular.IncluirUsuarioParticular(usuarioParticular))
{
Session["Usuario"] = usuarioParticular;
}
return(Json(new
{
info = "redirect",
data = Url.Action("UsuarioParticular", "Perfil")
}));
}
catch (Exception ex)
{
throw ex;
}
}
public JsonResult PrazosContrato(CadastroViewModel model)
{
var listaPrazos = RegrasClubR.Modalidade_PrazoContrato();
var prazos = listaPrazos.Where(m => m.ModalidadeClubR.Equals(model.ModalidadeClubR)).ToList();
return(Json(prazos));
}
public string Create(CadastroViewModel usuario)
{
Usuario user = new Usuario();
user.UserName = usuario.Email;
user.Nome = usuario.Nome;
user.Email = usuario.Email;
user.Deletado = usuario.Deletado;
Usuario usr;
IdentityResult result = _userManager.Create(user, usuario.Senha);
if (result.Succeeded)
{
usr = _userManager.FindByEmail(user.Email);
_userManager.AddToRoles(usr.Id, new[] { usuario.Grupo.ToString() });
return(usr.Id);
}
else
{
if (result.Errors != null)
{
string erros = "Erro ao criar usuário. ";
foreach (string error in result.Errors)
{
erros += error + "; ";
}
throw new System.Exception(erros);
}
}
return(null);
}
public async Task <IActionResult> Cadastro(CadastroViewModel model)
{
if (ModelState.IsValid)
{
var user = await this.UserManager.FindByNameAsync(model.Email);
if (user != null)
{
ModelState.AddModelError("", "Já existe um usuário cadastrado com essas informações!");
}
else
{
var userIdentity = new Infraestrutura.Identity.AppUser();
userIdentity.UserName = model.Email;
userIdentity.Email = model.Email;
userIdentity.Profile = new Perfil();
userIdentity.Profile.Nome = model.Nome;
var result = await this.UserManager.CreateAsync(userIdentity, model.Senha);
if (result.Succeeded)
{
return(RedirectToAction(nameof(SiteController.Index), "Site"));
}
else
{
}
}
}
return(View());
}
public Cadastro()
{
InitializeComponent();
this.Title = "Cadastro";
CadastroViewModel = new CadastroViewModel();
this.BindingContext = this.CadastroViewModel;
}
public async Task <IActionResult> Edit(Guid id, CadastroViewModel cadastroViewModel)
{
if (id != cadastroViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var cadastro = _mapper.Map <Cadastro>(cadastroViewModel);
await _cadastroRepository.Atualizar(cadastro);
await _cadastroRepository.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!await CadastroExists(cadastroViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cadastroViewModel));
}
public async Task <ActionResult> Create(CadastroViewModel model)
{
if (ModelState.IsValid)
{
var user = new Usuario
{
Nome = model.Nome,
UserName = model.Email,
Email = model.Email,
IdEmpresa = UsuarioLogado.IdEmpresa
//DataNascimento = model.DataNascimento,
//CPF = model.CPF,
//Telefone = model.Telefone,
//Celular = model.Celular,
};
var result = await _userManager.CreateAsync(user, model.Senha);
if (result.Succeeded)
{
//await _signInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
Usuario usr = _userManager.FindByEmail(model.Email);
await _userManager.AddToRolesAsync(usr.Id, new[] { model.Grupo.ToString() });
TempData["Nome"] = usr.Nome;
TempData["Acao"] = "criado";
return(RedirectToAction("Index"));
}
AddErrors(result);
}
return(View(model));
}
public JsonResult Versao(CadastroViewModel model)
{
var d = new SemCampanhaDAL();
int versao = d.Versao(model.Codun, model.CodCliente, model.IdTransacao);
return(Json(versao));
}
public ActionResult Cadastrar(CadastroViewModel model)
{
model.Usuario.DataCadastro = DateTime.Now.ToString();
model.Usuario.Habilidades = string.Empty;
if (Request.Form["Usuario.Habilidades"] != null)
{
var lista = Request.Form["Usuario.Habilidades"].Split(',');
foreach (var item in lista)
{
if (item.Length > 0)
{
model.Usuario.Habilidades += item + ",";
}
}
model.Usuario.Habilidades = model.Usuario.Habilidades.Substring(0, model.Usuario.Habilidades.Length - 1);
}
//var db = new FinderJobsContext();
//db.Usuarios.Add(model.Usuario);
//var id = db.SaveChanges();
//if (id > 0)
// TempData["mensagem"] = "Cadastro realizado!";
//else
// TempData["mensagem"] = "";
return View("Cadastro" + model.Usuario.Tipo);
}
public void VerificarSeInclui()
{
//arrange
var options = new DbContextOptionsBuilder <CaminhaoContext>()
.UseInMemoryDatabase("CaminhaoContext_" + DateTime.Now.ToFileTimeUtc())
.Options;
var contexto = new CaminhaoContext(options);
var repoCaminhaoModelo = new CaminhaoModeloRepository(contexto);
var repo = new CaminhaoRepository(contexto, repoCaminhaoModelo);
Caminhao caminhao = new Caminhao("Nome 1", 2020, 2021,
new CaminhaoModelo("FH", true));
CadastroViewModel cadastroViewModel = new CadastroViewModel();
cadastroViewModel.idCaminhao = 0;
cadastroViewModel.caminhao = caminhao;
var dbSet = contexto.Set <Caminhao>();
CaminhaoController caminhaoController = new CaminhaoController(
repoCaminhaoModelo,
repo
);
//act
caminhaoController.Inserir(cadastroViewModel);
//assert
Assert.Equal(1, dbSet.Count());
}
public CadastroView()
{
InitializeComponent();
var vaCadastroViewModel = new CadastroViewModel {
Mensagens = this, Navigation = this.Navigation
};
BindingContext = vaCadastroViewModel;
}
public IActionResult Cadastro()
{
var viewmodel = new CadastroViewModel();
viewmodel.Message = (string)TempData["msg-cadastro"];
viewmodel.ErrosCad = (string[])TempData["erros-cadastro"];
return(View(viewmodel));
}
public ActionResult Create(CadastroViewModel clinicaViewModel)
{
if (ModelState.IsValid)
{
clinicaAppService.Add(clinicaViewModel);
return(RedirectToAction("Index"));
}
return(View(clinicaViewModel));
}
public ActionResult Cadastro(CadastroViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
//INSERIR BASE REPOSITORY CRUD
return(Json("Ok"));
}
public ActionResult Edit(CadastroViewModel cadastroViewModel)
{
if (ModelState.IsValid)
{
pacienteAppService.Update(cadastroViewModel);
return(RedirectToAction("Index"));
}
return(View(cadastroViewModel));
}
public ActionResult Cadastro(CadastroViewModel model)
{
if (ModelState.IsValid)
{
try
{
var c = new Markup();
c.Usuario = new Usuario();
c.Campanha = Campanha.MarkUP;
c.Codun = model.Codun;
c.Versao = model.Versao;
c.NomeResponsavel = model.NomeResponsavel;
c.CpfResponsavel = model.CpfResponsavel;
c.Modalidade = model.ModalidadeMarkup;
c.DataNegociacao = model.DataNegociacao != null?Convert.ToDateTime(model.DataNegociacao) : (DateTime)SqlDateTime.MinValue;
c.DataInicio = Convert.ToDateTime(model.DataInicioContrato);
c.DataFim = Convert.ToDateTime(model.DataFimContrato);
c.MediaHistorica = Convert.ToDecimal(model.MediaHistorica.Replace(".", ""));
c.PeriodoMeses = model.PeriodoMeses;
c.MetaPeriodo = Convert.ToDecimal(model.MetaPeriodo.Replace(".", ""));
c.Markup = model.MarkUP;
c.Desconto = 1 - (2.52M / c.Markup);
c.Crescimento = Convert.ToDecimal(model.CrescimentoProposto.Replace("%", "").Replace(".", ","));
c.MesesPagamentoRBR = model.MesesPagamentoRBR;
c.NetlineHabilitado = model.MesesPagamentoNetline != 0;
c.MesesPagamentoNetline = model.MesesPagamentoNetline;
c.Guelta = model.Guelta;
c.Status = StatusSolicitacao.Pendente;
c.Observacao = model.Obervacao;
c.Acao = Acao.Cadastrar;
c.Usuario = model.usuario;
var d = new MarkupDAL();
d.Cadastrar(c);
var r = new RepresentanteDAL();
List <string> destinatarios = r.ListaDestinatarios(c.Usuario.IdUsuario);
Email.EnviarEmailMarkup(c, destinatarios);
TempData["Sucesso"] = true;
TempData["Resultado"] = "Solicitação de Cadastro enviada com sucesso. \n" +
"Um E-mail de confirmação foi enviado, assim que o cliente estiver cadastrado você receberá uma confirmação via E-mail";
return(RedirectToAction("Cadastro", "Markup"));
}
catch (Exception e)
{
TempData["Sucesso"] = false;
TempData["Resultado"] = "Erro: " + e.Message;
}
}
return(View(new CadastroViewModel()));
}
// GET: AreaRestrita/SemCampanha
public ActionResult Cadastro(int?id)
{
var model = new CadastroViewModel();
if (id != null)
{
model.IdTransacao = (int)id;
}
return(View(model));
}
public IActionResult Cadastro()
{
var model = new CadastroViewModel()
{
Titulo = "Cadastro de Anúncio",
RotaForm = "/Anuncio/Cadastro",
Dados = new Anuncio()
};
return(View("Form", model));
}
public CadastroPage(Usuario usuario)
{
// NavigationPage.SetHasNavigationBar(this, false);
CadastroViewModel cadastroViewModel = new CadastroViewModel();
BindingContext = cadastroViewModel;
navigationServices = new NavigationServices(); //nv tela
InitializeComponent();
TxtEmail.Text = usuario.email;
TxtSenha.Text = usuario.senha;
}