public async Task <IActionResult> Edit(int id, Membro membro)
{
if (!ModelState.IsValid)
{
var oscs = await _oscService.FindAllAsync();
var viewModel = new MembroViewModel {
Membro = membro, Oscs = oscs
};
return(View(viewModel));
}
if (id != membro.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id mismatch" }));
}
try
{
await _membroService.UpdateAsync(membro);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <ActionResult> Create(MembroViewModel collection)
{
IdentityResult identityResult;
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var result = _membroRepository.Adicionar(Membro(collection));
if (result != null)
{
IdentityUser identityUser = await _userManager.FindByEmailAsync(collection.Email);
if (identityUser != null)
{
identityResult = await _userManager.AddToRoleAsync(identityUser, "Membro");
if (identityResult.Succeeded)
{
await _signInManager.SignOutAsync();
HttpContext.Session.Remove("_UserEmail");
return(RedirectToAction("Eventos", "Evento"));
}
}
}
}
return(View(collection));
}
catch
{
return(View(collection));
}
}
// GET: Membro/Create
public async Task <ActionResult> Create(string email, string userId, string code)
{
if (email == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(NotFound($"Não foi possível carregar o usuário com o email '{email}'."));
}
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Não foi possível carregar o usuário com ID '{userId}'."));
}
MembroViewModel membro = new MembroViewModel();
membro.Email = email;
return(View(membro));
}
private Membro Membro(MembroViewModel model)
{
return(new Membro
{
MembroId = model.MembroId,
Nome = model.Nome,
Email = model.Email,
Telefone = model.Telefone
});
}
public async Task <IActionResult> Create()
{
var oscs = await _oscService.FindAllAsync();
var viewModel = new MembroViewModel {
Oscs = oscs
};
return(View(viewModel));
}
public static void AtualizarTelefoneMembro(this Telefone telefone, MembroViewModel membroViewModel, Usuario usuario)
{
telefone.UsuarioAlteracao = usuario;
telefone.DtCriacao = DateTime.Now;
telefone.DddTelComl = membroViewModel.DddTelComl;
telefone.TelefoneComl = membroViewModel.TelefoneComl;
telefone.DddCel = membroViewModel.DddCel;
telefone.Celular = membroViewModel.Celular;
telefone.Ativo = membroViewModel.Ativo;
telefone.Contato = membroViewModel.Contato;
telefone.Ativo = membroViewModel.Ativo;
}
// GET: Membros/Details/5
public ActionResult Details(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MembroViewModel membroViewModel = _membroAppService.GetById(id.Value);
if (membroViewModel == null)
{
return(HttpNotFound());
}
return(View(membroViewModel));
}
public ActionResult Edit(int id, MembroViewModel collection)
{
try
{
// TODO: Add update logic here
_membroRepository.Actualizar(Membro(collection));
string msg = "Dados alterados";
return(RedirectToAction("Details", new { msg = msg }));
}
catch
{
return(View());
}
}
public MembroViewModel Update(MembroViewModel membroViewModel)
{
BeginTransaction();
var membroReturn = _membroService.Update(Mapper.Map <MembroViewModel, Membro>(membroViewModel));
membroViewModel = Mapper.Map <Membro, MembroViewModel>(membroReturn);
if (membroReturn.ValidationResult.IsValid)
{
Commit();
}
return(membroViewModel);
}
public async Task <IActionResult> Create(Membro membro)
{
if (!ModelState.IsValid)
{
var oscs = await _oscService.FindAllAsync();
var viewModel = new MembroViewModel {
Membro = membro, Oscs = oscs
};
return(View(viewModel));
}
await _membroService.InsertAsync(membro);
return(RedirectToAction(nameof(Index)));
}
public HttpResponseMessage GetMembro(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
Membro membro = _membroRep.FindBy(m => m.PessoaId == usuario.Pessoa.Id).FirstOrDefault();
MembroViewModel estoqueVM = Mapper.Map <Membro, MembroViewModel>(membro);
response = request.CreateResponse(HttpStatusCode.OK, estoqueVM);
return response;
}));
}
// GET: Membros/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MembroViewModel membroViewModel = _membroAppService.GetById(id.Value);
if (membroViewModel == null)
{
return(HttpNotFound());
}
loadViewBags();
ViewBag.MembroId = id;
return(View(membroViewModel));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Error), new { message = "Id not provided" }));
}
var obj = await _membroService.FindByIdAsync(id.Value);
if (obj == null)
{
return(RedirectToAction(nameof(Error), new { message = "Id not found" }));
}
List <Osc> oscs = await _oscService.FindAllAsync();
MembroViewModel viewModel = new MembroViewModel {
Membro = obj, Oscs = oscs
};
return(View(viewModel));
}
public ActionResult Edit(MembroViewModel membroViewModel)
{
if (ModelState.IsValid)
{
membroViewModel = _membroAppService.Update(membroViewModel);
if (!membroViewModel.ValidationResult.IsValid)
{
foreach (var erro in membroViewModel.ValidationResult.Erros)
{
ModelState.AddModelError(string.Empty, erro.Message);
}
loadViewBags();
ViewBag.MembroId = membroViewModel.MembroId;
return(View(membroViewModel));
}
return(RedirectToAction("Index"));
}
loadViewBags();
ViewBag.MembroId = membroViewModel.MembroId;
return(View(membroViewModel));
}
public ActionResult CriarParcial(MembroViewModel membroView)
{
if (ModelState.IsValid)
{
var membro = new Membro();
var VerificaSede = _interfaceIgrejasApp.GetEntityById(membroView.IgrejaId);
if (VerificaSede.IgrejasId != null)
{
membro.IgrejaSede = VerificaSede.IgrejasId;
}
membro.Nome = membroView.NomeCompleto;
membro.CargoId = membroView.CargoId;
membro.DadosMinisteriais = membroView.DadosMinisteriais;
membro.DataNascimento = membroView.DataNascimento;
membro.Sexo = membroView.Sexo;
membro.Telefone = membroView.Telefone;
membro.IgrejaId = membroView.IgrejaId;
_interfaceMembro.Add(membro);
return(RedirectToAction("Index"));
}
return(View(membroView));
}
public static void AtualizarMembro(this Membro membro, MembroViewModel membroVm, Usuario usuario)
{
membro.UsuarioAlteracao = usuario;
membro.Pessoa.UsuarioAlteracao = usuario;
membro.Pessoa.PessoaJuridica.UsuarioAlteracao = usuario;
membro.Ativo = membroVm.Ativo;
membro.Pessoa.Ativo = membroVm.Ativo;
membro.Pessoa.PessoaJuridica.Ativo = membroVm.Ativo;
membro.Comprador = membroVm.Comprador;
membro.Pessoa.PessoaJuridica.NomeFantasia = membroVm.NomeFantasia;
membro.Pessoa.PessoaJuridica.Cnpj = membroVm.Cnpj;
membro.Pessoa.PessoaJuridica.RazaoSocial = membroVm.RazaoSocial;
membro.Pessoa.PessoaJuridica.DtFundacao = membroVm.DtFundacao;
membro.Pessoa.PessoaJuridica.Email = membroVm.Email;
membro.Pessoa.PessoaJuridica.InscEstadual = membroVm.InscEstadual;
membro.Vip = membroVm.Vip;
membro.DddTel = membroVm.DddTelComl;
membro.Telefone = membroVm.TelefoneComl;
membro.DddCel = membroVm.DddCel;
membro.Celular = membroVm.Celular;
membro.Contato = membroVm.Contato;
membro.FranquiaId = membroVm.FranquiaId;
membro.DataFimPeriodoGratuito = membroVm.DataFimPeriodoGratuito;
}
public HttpResponseMessage Atualizar(HttpRequestMessage request, MembroViewModel membroViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response;
//Remove essa propridades para não fazera validação pois
//na atualização do membro nao atualizao usuario do mesmo
ModelState.Remove("membroViewModel.Usuario.Senha");
ModelState.Remove("membroViewModel.Usuario.ConfirmSenha");
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var membro = _membroRep.GetSingle(membroViewModel.Id);
var usuario = _usuarioRep.GetSingle(1);
membro.AtualizarMembro(membroViewModel, usuario);
_unitOfWork.Commit();
//if (membroViewModel.TelefoneId == 0)
//{
// var telefone = new Telefone
// {
// UsuarioCriacao = usuario,
// DtCriacao = DateTime.Now,
// DddTelComl = membroViewModel.DddTelComl,
// TelefoneComl = membroViewModel.TelefoneComl,
// DddCel = membroViewModel.DddCel,
// Celular = membroViewModel.Celular,
// Ativo = membroViewModel.Ativo,
// Contato = membroViewModel.Contato
// };
// membro.Pessoa.Telefones.Add(telefone);
//}
//else
//{
// var telefone = _telefoneRep.GetSingle(membroViewModel.TelefoneId);
// telefone.AtualizarTelefoneMembro(membroViewModel, usuario);
//}
membro.Pessoa.Enderecos.ForEach(x => { x.LocalizacaoGoogle(); });
_unitOfWork.Commit();
// Update view model
membroViewModel = Mapper.Map <Membro, MembroViewModel>(membro);
response = request.CreateResponse(HttpStatusCode.OK, membroViewModel);
}
return response;
}));
}
public UsuarioRepository Run(Repository value)
{
UsuarioRepository r = (UsuarioRepository)value;
try
{
int _empresaId = int.Parse(System.Configuration.ConfigurationManager.AppSettings["empresaId"]);
Usuario entity = null;
if (seguranca_db.Usuarios.Where(info => info.keyword == r.keyword && info.empresaId == _empresaId).Count() > 0)
{
entity = seguranca_db.Usuarios.Where(info => info.keyword == r.keyword && info.empresaId == _empresaId).FirstOrDefault();
// Verifica se o código de ativação não expirou
if (entity.dt_keyword < Funcoes.Brasilia())
{
throw new ArgumentException("Data de ativação do cadastro expirou.");
}
else
{
#region Ativa o Usuário no módulo de Segurança e limpa a chave no cadastro de usuários
entity.keyword = null;
entity.dt_keyword = null;
entity.situacao = "A";
seguranca_db.Entry(entity).State = EntityState.Modified;
#endregion
#region Ativar o Apostador
Membro m = db.Membros.Where(info => info.Email == entity.login).FirstOrDefault();
MembroModel MembroModel = new MembroModel(this.db, this.seguranca_db);
MembroViewModel MembroViewModel = MembroModel.MapToRepository(m);
MembroViewModel.IndSituacao = "A";
MembroViewModel.uri = r.uri;
MembroViewModel = MembroModel.Update(MembroViewModel);
if (MembroViewModel.mensagem.Code > 0)
{
throw new ArgumentException(MembroViewModel.mensagem.MessageBase);
}
#endregion
r.mensagem = MembroViewModel.mensagem;
}
}
else
{
throw new ArgumentException("Cadastro já ativado ou código de verificação incorreto");
}
}
catch (ArgumentException ex)
{
r.mensagem = new Validate()
{
Code = 999, Message = MensagemPadrao.Message(999).ToString(), MessageBase = ex.Message
};
}
catch (App_DominioException ex)
{
r.mensagem = ex.Result;
if (ex.InnerException != null)
{
r.mensagem.MessageBase = new App_DominioException(ex.InnerException.Message ?? ex.Message, GetType().FullName).Message;
}
else
{
r.mensagem.MessageBase = new App_DominioException(ex.Result.Message, GetType().FullName).Message;
}
}
catch (DbUpdateException ex)
{
r.mensagem.MessageBase = ex.InnerException.InnerException.Message ?? ex.Message;
if (r.mensagem.MessageBase.ToUpper().Contains("REFERENCE"))
{
if (r.mensagem.MessageBase.ToUpper().Contains("DELETE"))
{
r.mensagem.Code = 16;
r.mensagem.Message = MensagemPadrao.Message(16).ToString();
r.mensagem.MessageType = MsgType.ERROR;
}
else
{
r.mensagem.Code = 28;
r.mensagem.Message = MensagemPadrao.Message(28).ToString();
r.mensagem.MessageType = MsgType.ERROR;
}
}
else if (r.mensagem.MessageBase.ToUpper().Contains("PRIMARY"))
{
r.mensagem.Code = 37;
r.mensagem.Message = MensagemPadrao.Message(37).ToString();
r.mensagem.MessageType = MsgType.WARNING;
}
else if (r.mensagem.MessageBase.ToUpper().Contains("UNIQUE KEY"))
{
r.mensagem.Code = 54;
r.mensagem.Message = MensagemPadrao.Message(54).ToString();
r.mensagem.MessageType = MsgType.WARNING;
}
else
{
r.mensagem.Code = 44;
r.mensagem.Message = MensagemPadrao.Message(44).ToString();
r.mensagem.MessageType = MsgType.ERROR;
}
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
r.mensagem = new Validate()
{
Code = 42, Message = MensagemPadrao.Message(42).ToString(), MessageBase = ex.EntityValidationErrors.Select(m => m.ValidationErrors.First().ErrorMessage).First()
};
}
catch (Exception ex)
{
r.mensagem.Code = 17;
r.mensagem.Message = MensagemPadrao.Message(17).ToString();
r.mensagem.MessageBase = new App_DominioException(ex.InnerException.InnerException.Message ?? ex.Message, GetType().FullName).Message;
r.mensagem.MessageType = MsgType.ERROR;
}
return(r);
}
public HttpResponseMessage Inserir(HttpRequestMessage request, MembroViewModel membroViewModel)
{
membroViewModel.Cnpj = membroViewModel.Cnpj.Replace('.', ' ').Replace('/', ' ').Replace('-', ' ');
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
if (_membroRep.CnpjExistente(membroViewModel.Cnpj) > 0)
{
ModelState.AddModelError("CNPJ Existente", "CNPJ:" + membroViewModel.Cnpj + " já existe .");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var usuario = _usuarioRep.GetSingle(1);
var pessoa = new Pessoa
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
TipoPessoa = TipoPessoa.PessoaJuridica,
Ativo = membroViewModel.Ativo,
};
var pessoaJuridica = new PessoaJuridica
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Pessoa = pessoa,
NomeFantasia = membroViewModel.NomeFantasia,
Cnpj = membroViewModel.Cnpj,
RazaoSocial = membroViewModel.RazaoSocial,
DtFundacao = membroViewModel.DtFundacao,
Email = membroViewModel.Email,
InscEstadual = membroViewModel.InscEstadual,
Ativo = membroViewModel.Ativo
};
_pessoaJuridicaRep.Add(pessoaJuridica);
_unitOfWork.Commit();
pessoa.PessoaJuridica = pessoaJuridica;
_pessoaRep.Edit(pessoa);
_unitOfWork.Commit();
var novoMembro = new Membro
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Pessoa = pessoa,
Comprador = membroViewModel.Comprador,
Ativo = membroViewModel.Ativo,
Vip = membroViewModel.Vip,
DddTel = membroViewModel.DddTelComl,
Telefone = membroViewModel.TelefoneComl,
DddCel = membroViewModel.DddCel,
Celular = membroViewModel.Celular,
Contato = membroViewModel.Contato,
FranquiaId = membroViewModel.FranquiaId,
DataFimPeriodoGratuito = DateTime.Now.AddDays(30)
};
_membroRep.Add(novoMembro);
_unitOfWork.Commit();
var email = new Emails
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
AssuntoEmail = "Novo Membro Cliente PJ",
EmailDestinatario = "*****@*****.**",
CorpoEmail = "NOVO CLIENTE",
Status = Status.NaoEnviado,
Origem = 0,
Ativo = true
};
_emailsRep.Add(email);
_unitOfWork.Commit();
// Update view model
membroViewModel = Mapper.Map <Membro, MembroViewModel>(novoMembro);
response = request.CreateResponse(HttpStatusCode.Created, membroViewModel);
}
}
return response;
}));
}
