private static async Task <string> EnsureUser(IServiceProvider serviceProvider,
string testUserPw, string UserName, int ProfileID, bd_lesContext _context)
{
var userManager = serviceProvider.GetService <UserManager <ApplicationUsers> >();
var func = new Funcionario {
NomeCompleto = UserName
};
var user = await userManager.FindByNameAsync(UserName);
if (user == null && UserName != null && ProfileID != 0)
{
_context.Add(func);
await _context.SaveChangesAsync();
user = new ApplicationUsers {
UserName = UserName, FuncionarioIdFuncionario = func.IdFuncionario, IdPerfil = ProfileID
};
var result = await userManager.CreateAsync(user, testUserPw);
if (!result.Succeeded)
{
Console.WriteLine(result.Errors);
_context.Remove(func);
await _context.SaveChangesAsync();
}
}
return(user.Id);
}
public async Task <IActionResult> Create([Bind("IdLocalCaptura,Localidade,Latitude,Longitude,ConcelhoId,DistritoId")] Localcaptura localcaptura)
{
//validation
var val_concelho_distrito = await _context.Concelho
.SingleOrDefaultAsync(m => m.IdConcelho == localcaptura.ConcelhoId);
if (val_concelho_distrito.DistritoId != localcaptura.DistritoId)
{
ModelState.AddModelError("DistritoId", "O distrito selecionado não contém o concelho selecionado.");
ModelState.AddModelError("ConcelhoId", "O concelho selecionado não pertence ao distrito selecionado.");
}
if (ModelState.IsValid)
{
_context.Add(localcaptura);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DistritoId"] = new SelectList(_context.Distrito, "IdDistrito", "NomeDistrito").Prepend(new SelectListItem()
{
Text = "---Selecione um Distrito---", Value = ""
});
ViewData["ConcelhoId"] = new SelectList(_context.Concelho, "IdConcelho", "NomeConcelho").Prepend(new SelectListItem()
{
Text = "---Selecione um Concelho---", Value = ""
});
return(View(localcaptura));
}
public async Task <IActionResult> Create([Bind("IdFamilia,NomeFamilia,GrupoIdGrupo")] Familia familia)
{
//validation
if (familia.NomeFamilia == null)
{
ModelState.AddModelError("NomeFamilia", "O nome é um campo requirido.");
}
if (familia.GrupoIdGrupo == 0)
{
ModelState.AddModelError("GrupoId", "É requirido que cada família pertença a um grupo.");
}
var val_nome = await _context.Familia
.SingleOrDefaultAsync(m => m.NomeFamilia == familia.NomeFamilia);
if (val_nome != null)
{
ModelState.AddModelError("NomeFamilia", "Não podem existir duas familias com o mesmo nome.");
}
if (ModelState.IsValid)
{
_context.Add(familia);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GrupoIdGrupo"] = new SelectList(_context.Grupo, "IdGrupo", "NomeGrupo", familia.GrupoIdGrupo).Prepend(new SelectListItem()
{
Text = "---Selecione um Grupo---", Value = ""
});
return(View(familia));
}
public async Task <IActionResult> Create([Bind("IdLote,CodigoLote,DataInicio,DataFim,Observacoes,RegNovosAnimaisIdRegAnimal,FuncionarioIdFuncionario")] Lote lote)
{
//validation
var val_code = await _context.Lote
.SingleOrDefaultAsync(m => m.CodigoLote == lote.CodigoLote);
if (val_code != null)
{
ModelState.AddModelError("CodigoLote", string.Format("Já existe um lote com o código {0}.", lote.CodigoLote));
}
if (lote.DataFim < lote.DataInicio)
{
ModelState.AddModelError("DataFim", "A Data de Fim é menor que a Data de Inicio.");
ModelState.AddModelError("DataInicio", "A Data de Fim é menor que a Data de Inicio.");
}
if (ModelState.IsValid)
{
_context.Add(lote);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", lote.FuncionarioIdFuncionario);
ViewData["RegNovosAnimaisIdRegAnimal"] = new SelectList(_context.RegNovosAnimais, "IdRegAnimal", "RespTransporte", lote.RegNovosAnimaisIdRegAnimal);
return(View(lote));
}
public async Task <IActionResult> Create([Bind("IdGrupo,NomeGrupo")] Grupo grupo)
{
//validation
if (grupo.NomeGrupo == null)
{
ModelState.AddModelError("NomeGrupo", "O nome é um campo requirido.");
}
var val_nome = await _context.Grupo
.SingleOrDefaultAsync(m => m.NomeGrupo == grupo.NomeGrupo);
if (val_nome != null)
{
ModelState.AddModelError("NomeGrupo", "Não podem existir dois grupos com o mesmo nome.");
}
if (ModelState.IsValid)
{
_context.Add(grupo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(grupo));
}
public async Task <IActionResult> Create([Bind("IdEnsaio,DataInicio,DataFim,DescTratamento,GrauSeveridade,NroAnimaisAutoriz,ProjetoIdProjeto,LoteIdLote")] Ensaio ensaio)
{
if (ensaio.DataFim < ensaio.DataInicio)
{
ModelState.AddModelError("DataFim", "A Data de Fim é menor que a Data de Inicio");
ModelState.AddModelError("DataInicio", "A Data de Fim é menor que a Data de Inicio");
}
var projetos = _context.Projeto.Where(b => EF.Property <int>(b, "IdProjeto") == ensaio.ProjetoIdProjeto);
foreach (var projeto in projetos)
{
if (ensaio.NroAnimaisAutoriz > projeto.NroAnimaisAutoriz)
{
ModelState.AddModelError("NroAnimaisAutoriz", "Nº de Animais excede o permitido para o Projeto selecionado" + "(" + projeto.NroAnimaisAutoriz + ")");
}
}
if (ModelState.IsValid)
{
_context.Add(ensaio);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["LoteIdLote"] = new SelectList(_context.Lote, "IdLote", "CodigoLote", ensaio.LoteIdLote);
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto, "IdProjeto", "Nome", ensaio.ProjetoIdProjeto);
return(View(ensaio));
}
public async Task <IActionResult> Create([Bind("IdCircuito,ProjetoIdProjeto,CodigoCircuito,DataCriacao,DataFinal")] CircuitoTanque circuitoTanque)
{
if (circuitoTanque.DataCriacao > circuitoTanque.DataFinal)
{
ModelState.AddModelError("DataCriacao", string.Format("Data inicial não pode ser posterior á data inicial", circuitoTanque.DataCriacao));
}
var cTfindany = _context.CircuitoTanque.Where(b => EF.Property <int>(b, "ProjetoIdProjeto") == circuitoTanque.ProjetoIdProjeto).Where(b => EF.Property <int>(b, "isarchived") == 0);
if (cTfindany.Any())
{
ModelState.AddModelError("ProjetoIdProjeto", string.Format("Este Projecto ja possui um Circuito Tanque Associado", circuitoTanque.ProjetoIdProjeto));
}
var cTCodefindany = _context.CircuitoTanque.Where(b => EF.Property <string>(b, "CodigoCircuito").Equals(circuitoTanque.CodigoCircuito));
if (cTCodefindany.Any())
{
ModelState.AddModelError("CodigoCircuito", string.Format("Já Existe um circuito com este Código", circuitoTanque.CodigoCircuito));
}
if (ModelState.IsValid)
{
_context.Add(circuitoTanque);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto.Where(c => c.isarchived == 0), "IdProjeto", "Nome", circuitoTanque.ProjetoIdProjeto);
return(View(circuitoTanque));
}
public async Task <IActionResult> Create([Bind("IdTipoEstatutoGenetico,TipoEstatutoGeneticocol")] Tipoestatutogenetico tipoestatutogenetico)
{
if (ModelState.IsValid)
{
_context.Add(tipoestatutogenetico);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tipoestatutogenetico));
}
public async Task <IActionResult> Create([Bind("IdFuncionario,NomeCompleto,NomeUtilizador,Password,Telefone")] Funcionario funcionario)
{
if (ModelState.IsValid)
{
_context.Add(funcionario);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(funcionario));
}
public async Task <IActionResult> Create([Bind("IdPlanAlim,Nome,MarcaAlim,Tipo,Temperatura,Racao,RacaoDia")] PlanoAlimentar planoAlimentar)
{
if (ModelState.IsValid)
{
_context.Add(planoAlimentar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(planoAlimentar));
}
public async Task <IActionResult> Create([Bind("IdMotivo,TipoMotivo,NomeMotivo")] Motivo motivo)
{
if (ModelState.IsValid)
{
_context.Add(motivo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(motivo));
}
public async Task <IActionResult> Create([Bind("IdFornColect,Tipo,Nome,Nif,NroLicenca,Morada,Telefone")] Fornecedorcolector fornecedorcolector)
{
if (ModelState.IsValid)
{
_context.Add(fornecedorcolector);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(fornecedorcolector));
}
public async Task <IActionResult> Create([Bind("IdTOrigem,descricao")] TOrigem tOrigem)
{
if (ModelState.IsValid)
{
_context.Add(tOrigem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tOrigem));
}
public async Task <IActionResult> Create([Bind("Id,NomeDistrito")] Distrito distrito)
{
if (ModelState.IsValid)
{
_context.Add(distrito);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(distrito));
}
public async Task <IActionResult> Create([Bind("IdPerfil,NomePerfil,IsDefault")] Perfil Perfil, List <string> roles)
{
//validation
var val_code = await _context.Perfil
.SingleOrDefaultAsync(p => p.NomePerfil == Perfil.NomePerfil);
if (val_code != null)
{
ModelState.AddModelError("NomePerfil", string.Format("Já existe um Perfil com o nome {0}.", Perfil.NomePerfil));
}
if (ModelState.IsValid)
{
//check if default exists
if (Perfil.IsDefault == 1)
{
var default_profile = await _context.Perfil.SingleOrDefaultAsync(p => p.IsDefault == 1);
default_profile.IsDefault = 0;
_context.Perfil.Attach(default_profile);
_context.Entry(default_profile).Property(p => p.IsDefault).IsModified = true;
}
else
{
Perfil.IsDefault = 0;
}
_context.Add(Perfil);
foreach (string role in roles)
{
_context.Add(new ProfileRole {
IdPerfil = Perfil.IdPerfil, RoleId = await _roleManager.GetRoleIdAsync(await _roleManager.FindByNameAsync(role))
});
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["checked"] = roles;
return(View(Perfil));
}
public async Task <IActionResult> Create([Bind("Id,NomeConselho,DistritoId")] Conselho conselho)
{
if (ModelState.IsValid)
{
_context.Add(conselho);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DistritoId"] = new SelectList(_context.Distrito, "Id", "Id", conselho.DistritoId);
return(View(conselho));
}
public async Task <IActionResult> Create([Bind("IdLocalCaptura,Localidade,Latitude,Longitude,ConselhoId,ConselhoDistritoId")] Localcaptura localcaptura)
{
if (ModelState.IsValid)
{
_context.Add(localcaptura);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ConselhoId"] = new SelectList(_context.Conselho, "Id", "NomeConselho", localcaptura.ConselhoId);
return(View(localcaptura));
}
public async Task <IActionResult> Create([Bind("IdRegAmo,Data,PesoMedio,NroIndividuos,PesoTotal,TanqueIdTanque")] RegAmostragens regAmostragens)
{
if (ModelState.IsValid)
{
_context.Add(regAmostragens);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque");
return(View(regAmostragens));
}
public async Task <IActionResult> Create([Bind("IdRegRemo,Date,NroRemoções,MotivoIdMotivo,CausaMorte,TanqueIdTanque")] RegRemocoes regRemocoes)
{
if (ModelState.IsValid)
{
_context.Add(regRemocoes);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MotivoIdMotivo"] = new SelectList(_context.Motivo, "IdMotivo", "NomeMotivo", regRemocoes.MotivoIdMotivo);
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque");
return(View(regRemocoes));
}
public async Task <IActionResult> Create([Bind("Função,ProjetoIdProjeto,FuncionarioIdFuncionario")] Elementoequipa elementoequipa)
{
if (ModelState.IsValid)
{
_context.Add(elementoequipa);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", elementoequipa.FuncionarioIdFuncionario);
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto, "IdProjeto", "Nome", elementoequipa.ProjetoIdProjeto);
return(View(elementoequipa));
}
public async Task <IActionResult> Create(RegisterViewModel registerViewModel)
{
var user2 = await _userManager.FindByNameAsync(registerViewModel.UserName);
if (user2 != null)
{
ModelState.AddModelError("UserName", string.Format("Já existe um utilizador com o nome {0}.", registerViewModel.UserName));
}
if (ModelState.IsValid)
{
var func = new Funcionario {
NomeCompleto = registerViewModel.NomeCompleto
};
if (registerViewModel.NomeCompleto != null)
{
_context.Add(func);
await _context.SaveChangesAsync();
}
var user = new ApplicationUsers {
UserName = registerViewModel.UserName, PhoneNumber = registerViewModel.PhoneNumber, FuncionarioIdFuncionario = func.IdFuncionario, IdPerfil = registerViewModel.IdPerfil
};
var result = await _userManager.CreateAsync(user, registerViewModel.Password);
if (result.Succeeded)
{
List <ProfileRole> roles = await _context.ProfileRole
.Where(p => p.IdPerfil == user.IdPerfil)
.ToListAsync();
foreach (ProfileRole role in roles)
{
string role_name = _roleManager.FindByIdAsync(role.RoleId).Result.Name;
if (await _roleManager.RoleExistsAsync(role_name))
{
await _userManager.AddToRoleAsync(user, role_name);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
_context.Remove(func);
await _context.SaveChangesAsync();
}
}
ViewData["IdPerfil"] = new SelectList(_context.Perfil, "IdPerfil", "NomePerfil").Prepend(new SelectListItem()
{
Text = "---Selecione um Perfil---", Value = ""
});
return(View(registerViewModel));
}
public async Task <IActionResult> Create([Bind("IdRegMan,Data,TipoManuntecaoIdTManutencao,TanqueIdTanque")] RegManutencao regManutencao)
{
if (ModelState.IsValid)
{
_context.Add(regManutencao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque");
ViewData["TipoManuntecaoIdTManutencao"] = new SelectList(_context.TipoManuntecao, "IdTManutencao", "TManutencao");
return(View(regManutencao));
}
private static async Task <int> EnsureProfile(string ProfileName, int Default, bd_lesContext _context)
{
var profile = await _context.Perfil.SingleOrDefaultAsync(p => p.NomePerfil == ProfileName);
if (profile == null && ProfileName != null)
{
profile = new Perfil {
NomePerfil = ProfileName, IsDefault = Default
};
_context.Add(profile);
await _context.SaveChangesAsync();
}
return(profile.IdPerfil);
}
public async Task<IActionResult> Create([Bind("IdRegAnimal,NroExemplares,NroMachos,NroFemeas,Imaturos,Juvenis,Larvas,Ovos,DataNasc,Idade,PesoMedio,CompMedio,DuracaoViagem,TempPartida,TempChegada,NroContentores,TipoContentor,VolContentor,VolAgua,NroCaixasIsoter,NroMortosCheg,SatO2transp,Anestesico,Gelo,AdicaoO2,Arejamento,Refrigeracao,Sedação,RespTransporte,EspecieIdEspecie,FornecedorIdFornColect,TOrigemIdTOrigem,LocalCapturaIdLocalCaptura,TipoEstatutoGeneticoIdTipoEstatutoGenetico,FuncionarioIdFuncionario,FuncionarioIdFuncionario1")] RegNovosAnimais regNovosAnimais)
{
if (ModelState.IsValid)
{
_context.Add(regNovosAnimais);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
ViewData["FornecedorIdFornColect"] = new SelectList(_context.Fornecedorcolector, "IdFornColect", "Tipo", regNovosAnimais.FornecedorIdFornColect);
ViewData["FuncionarioIdFuncionario1"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", regNovosAnimais.FuncionarioIdFuncionario1);
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", regNovosAnimais.FuncionarioIdFuncionario);
ViewData["TOrigemIdTOrigem"] = new SelectList(_context.TOrigem, "IdTOrigem", "IdTOrigem", regNovosAnimais.TOrigemIdTOrigem);
ViewData["TipoEstatutoGeneticoIdTipoEstatutoGenetico"] = new SelectList(_context.Tipoestatutogenetico, "IdTipoEstatutoGenetico", "IdTipoEstatutoGenetico", regNovosAnimais.TipoEstatutoGeneticoIdTipoEstatutoGenetico);
return View(regNovosAnimais);
}
public async Task <IActionResult> Create([Bind("IdProjeto,Nome,DataInicio,DataFim,AutorizacaoDgva,RefOrbea,SubmisInsEurop,NroAnimaisAutoriz")] Projeto projeto)
{
if (projeto.DataFim < projeto.DataInicio)
{
ModelState.AddModelError("DataFim", "A Data de Fim é menor que a Data de Inicio");
ModelState.AddModelError("DataInicio", "A Data de Fim é menor que a Data de Inicio");
}
if (ModelState.IsValid)
{
_context.Add(projeto);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(projeto));
}
public async Task <IActionResult> Create([Bind("IdFinalidade,TFinalidade")] Finalidade finalidade)
{
var cTCodefindany = _context.Finalidade.Where(b => EF.Property <string>(b, "TFinalidade").Equals(finalidade.TFinalidade));
if (cTCodefindany.Any())
{
ModelState.AddModelError("TFinalidade", string.Format("Esta Finalidade já existe.", finalidade.TFinalidade));
}
if (ModelState.IsValid)
{
_context.Add(finalidade);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(finalidade));
}
public async Task <IActionResult> Create([Bind("IdAgenTra,NomeAgenTra")] AgenteTrat agenteTrat)
{
var cTCodefindany = _context.AgenteTrat.Where(b => EF.Property <string>(b, "NomeAgenTra").Equals(agenteTrat.NomeAgenTra));
if (cTCodefindany.Any())
{
ModelState.AddModelError("NomeAgenTra", string.Format("Este Agente de Tratamento já existe.", agenteTrat.NomeAgenTra));
}
if (ModelState.IsValid)
{
_context.Add(agenteTrat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(agenteTrat));
}
public async Task <IActionResult> Create([Bind("IdTManutencao,TManutencao")] TipoManuntecao tipoManuntecao)
{
var cTCodefindany = _context.TipoManuntecao.Where(b => EF.Property <string>(b, "TManutencao").Equals(tipoManuntecao.TManutencao));
if (cTCodefindany.Any())
{
ModelState.AddModelError("TManutencao", string.Format("Este Tipo de Manutenção já existe.", tipoManuntecao.TManutencao));
}
if (ModelState.IsValid)
{
_context.Add(tipoManuntecao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tipoManuntecao));
}
public async Task <IActionResult> Create([Bind("IdEspecie,NomeCient,NomeVulgar,FamiliaIdFamilia,FamiliaGrupoIdGrupo")] Especie especie)
{
//validation
if (especie.NomeCient == null)
{
ModelState.AddModelError("NomeCient", "O nome científico é um campo requirido.");
}
if (especie.NomeVulgar == null)
{
ModelState.AddModelError("NomeVulgar", "O nome vulgar é um campo requirido.");
}
var val_nomecient = await _context.Especie
.SingleOrDefaultAsync(m => m.NomeCient == especie.NomeCient);
if (val_nomecient != null)
{
ModelState.AddModelError("NomeCient", "Não podem existir duas espécies com o mesmo nome científico.");
}
var val_family_group = await _context.Familia
.SingleOrDefaultAsync(m => m.IdFamilia == especie.FamiliaIdFamilia);
if (val_family_group.GrupoIdGrupo != especie.FamiliaGrupoIdGrupo)
{
ModelState.AddModelError("FamiliaIdFamilia", "A familia selecionada não pertence ao grupo selecionado.");
ModelState.AddModelError("FamiliaGrupoIdGrupo", "O grupo selecionado não contém a familia selecionada.");
}
if (ModelState.IsValid)
{
_context.Add(especie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FamiliaIdFamilia"] = new SelectList(_context.Familia, "IdFamilia", "NomeFamilia", especie.FamiliaIdFamilia).Prepend(new SelectListItem()
{
Text = "---Selecione uma Familia---", Value = ""
});
ViewData["GrupoIdGrupo"] = new SelectList(_context.Grupo, "IdGrupo", "NomeGrupo", especie.FamiliaGrupoIdGrupo).Prepend(new SelectListItem()
{
Text = "---Selecione um Grupo---", Value = ""
});
return(View(especie));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var func = new Funcionario {
NomeCompleto = model.NomeCompleto
};
if (model.NomeCompleto != null)
{
_context.Add(func);
await _context.SaveChangesAsync();
}
var default_profile = await _context.Perfil.SingleOrDefaultAsync(p => p.IsDefault == 1);
var user = new ApplicationUsers {
UserName = model.UserName, PhoneNumber = model.PhoneNumber, FuncionarioIdFuncionario = func.IdFuncionario, IdPerfil = (model.IdPerfil == 0) ? default_profile.IdPerfil : model.IdPerfil
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
//await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
else
{
_context.Remove(func);
await _context.SaveChangesAsync();
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}