public ActionResult Index()
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
var user = _readOnlyRepository.FirstOrDefault <User>(x => x.Email == authTicket.UserData);
if (user != null)
{
var model = new ProjectListModel();
var typelist =
from ProjectEntity ute in _readOnlyRepository.GetAll <ProjectEntity>()
where ute.UserId == user.Id && !ute.Archived
select ute;
var typeList = new List <ProjectEntity>(typelist);
model.ProjectList = new List <ProjectListModel>();
foreach (var tL in typeList)
{
model.ProjectList.Add(new ProjectListModel
{
ProjectId = tL.Id,
ProjectName = tL.ProjectName,
ProjectDescription = tL.ProjectDescription
});
}
return(View(model));
}
}
return(RedirectToAction("Logout", "User"));
}
public ActionResult Login(AccountLoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = _readOnlyRepository.FirstOrDefault <User>(x => x.Email == model.Email);
if (user != null)
{
if (PasswordEncryptionService.CheckPassword(user, model.Password))
{
var ticket = new FormsAuthenticationTicket(1, user.Name, DateTime.Now, DateTime.Now.AddMinutes(30), model.RememberMe, user.Email, FormsAuthentication.FormsCookiePath);
// Encrypt the ticket.
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Synergy"));
}
}
ModelState.AddModelError("", "The e-mail address or password provided is incorrect.");
}
return(View(model));
}
public ActionResult AnswerQuestions(long id)
{
var questionToBeAnswered = _readOnlyRepository.FirstOrDefault <Questions>(x => x.Id == id && !x.Archived);
var answermodel = new AnswerModel {
FaqQuestion = questionToBeAnswered
};
return(View(answermodel));
}
public AuthModel FinishEditing([FromBody] adminModel model)
{
var nlea = _readOnlyRepository.FirstOrDefault <League>(x => x.Id == model.Id);
nlea.Name = model.Name;
nlea.Day = model.Day;
nlea.Location = model.Location;
var eLeague = nlea;
var editLeague = _writeOnlyRepository.Update(eLeague);
var authModel = new AuthModel {
};
return(authModel);
}
public AuthModel Login([FromBody] AccountLoginModel model)
{
var user = _readOnlyRepository.FirstOrDefault <Account>(x => x.Email == model.Email);
if (user == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, "User doesn't exist.");
}
if (!user.CheckPassword(model.Password))
{
throw new HttpException((int)HttpStatusCode.Unauthorized, "Password doesn't match.");
}
var authModel = new AuthModel
{
email = user.Email,
access_token = AuthRequestFactory.BuildEncryptedRequest(user.Email),
role = new RoleModel
{
bitMask = 2, title = "admin"
}
};
return(authModel);
}
public AuthModel ForgotPassword([FromBody] ForgotPasswordModel model)
{
var resp = SendSimpleMessage(model.Email);
var user = _readOnlyRepository.FirstOrDefault <Account>(x => x.Email == model.Email);
var authModel = new AuthModel {
Token = "SuperHash"
};
return(authModel);
}
public List <LeaguesModel> GetSuscribedLeagues()
{
var userTokenModel = GetUserTokenModel();
if (userTokenModel == null)
{
throw new HttpException((int)HttpStatusCode.Unauthorized, "User is not authorized");
}
var account = _readOnlyRepository.FirstOrDefault <Account>(x => x.Email == userTokenModel.email);
var leaguesModel = _mappingEngine.Map <List <Leagues>, List <LeaguesModel> >(account.Leagues.ToList());
return(leaguesModel);
}
public ActionResult Recommend(long id)
{
var css = _readOnlyRepository.GetById <Classified>(id);
var client = _readOnlyRepository.FirstOrDefault <User>(x => x.Nombre == (string)Session["User"]);
if (css.IdUsuario == client.Id)
{
this.AddNotification("No se puede recomendar su propio clasificado!", NotificationType.Warning);
return(RedirectToAction("Index", "Home"));
}
css.Recomendado += 1;
_writeOnlyRepository.Update(css);
return(RedirectToAction("Index", "Home"));
}
public ActionResult NewClassified()
{
if ((string)Session["User"] == "Anonymous")
{
this.AddNotification("Porfavor ingrese sesion antes de crear clasificado", NotificationType.Info);
return(RedirectToAction("Login"));
}
var user = _readOnlyRepository.FirstOrDefault <User>(x => x.Nombre == (string)Session["User"]);
if (user.Miembro == false && user.TotalClasificados >= 5 && (string)Session["Role"] == "user")
{
this.AddNotification("Ha llegado a su limite de creacion. Si le agrado nuestra pagina hagase miembro.", NotificationType.Info);
return(RedirectToAction("Index", "Home"));
}
return(View(new ClassifiedModel()));
}
public AuthModel resetpassword([FromBody] resetModel model)
{
var user = _readOnlyRepository.FirstOrDefault <Account>(x => x.Name == model.DisplayName);
user.Password = model.Password;
var newuser = user;
var reset = _writeOnlyRepository.Update(newuser);
var authModel = new AuthModel
{
};
return(authModel);
}
public ActionResult ManageUsers(long id)
{
var managerModel = new ManagerModel();
managerModel.UserToBeArchived = _readOnlyRepository.FirstOrDefault <AccountLogin>(x => x.Id == id);
if (!managerModel.UserToBeArchived.Archived)
{
managerModel.UserToBeArchived.Archived = true;
}
else
{
managerModel.UserToBeArchived.Archived = false;
}
_writeOnlyRepository.Update(managerModel.UserToBeArchived);
return(View(managerModel));
}
public ActionResult Register(RegisterModel rModel)
{
if (ModelState.IsValid)
{
var user = _readOnlyRepository.FirstOrDefault <AccountLogin>(x => x.Email == rModel.Email);
if (user != null)
{
//check
MessageBox.Show("User Exists.");
}
else
{
var registeredAccount = new AccountLogin(rModel.Email, rModel.Name, (new Hasher()).Encrypt(rModel.Password), "user");
_writeOnlyRepository.Create(registeredAccount);
MailTo.SendSimpleMessage(rModel.Email, rModel.Name, "Gracias por Registrarse");
} ModelState.AddModelError("", "Something went wrong with your credentials.");
}
return(View(rModel));
}
public AuthModel ForgotPassword([FromBody] ResetpPaswordModel model)
{
var user = _readOnlyRepository.FirstOrDefault <Account>(x => x.Email == model.Email);
var resp = SendSimpleMessage(model.Email, user.Password);
if (user == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, "User doesn't exist.");
}
var authModel = new AuthModel
{
Email = user.Email,
AccessToken = AuthRequestFactory.BuildEncryptedRequest(user.Email),
role = new RoleModel
{
bitMask = 2,
title = "admin"
}
};
return(authModel);
}
public ActionResult Contact(ContactModel cModel)
{
if (!this.IsCaptchaValid("Captcha is not valid"))
{
return(View(cModel));
}
var user = _readOnlyRepository.FirstOrDefault <AccountLogin>(x => x.Id == 1);
if (ModelState.IsValid)
{
var messageList = user.AccountMessages.ToList();
messageList.Add(new Messages(cModel.Email, cModel.Name, cModel.Message, cModel.Subject));
user.AccountMessages = messageList;
_writeOnlyRepository.Update(user);
//check
ViewBag.Message = "Successfully sent..!";
}
ModelState.AddModelError("", "Something went wrong with your values.");
return(View(cModel));
}
public ActionResult CreateClassified(ClassifiedModel model)
{
if (ModelState.IsValid)
{
var validate = new IValidate();
var user = _readOnlyRepository.FirstOrDefault <AccountLogin>(x => x.Email == HttpContext.User.Identity.Name);
var classifiedsList = user.AccountClassifieds.ToList();
classifiedsList.Add(new Classifieds(model.Category, model.Article, model.ArticleModel, model.Location,
model.Price, model.Description, user.Email, model.UrlImage, model.UrlImage1, model.UrlImage2, model.UrlImage3, model.UrlImage4, validate.Embed(model.UrlVideo)));
user.AccountClassifieds = classifiedsList;
_writeOnlyRepository.Update(user);
var notifyList = _readOnlyRepository.GetAll <Subscriptions>().Where(x => x.Following == user.Id && !x.Archived);
if (!notifyList.Any())
{
foreach (var x in notifyList)
{
var userToBeNotify = _readOnlyRepository.FirstOrDefault <AccountLogin>(z => z.Id == x.Follower);
var list = userToBeNotify.Notifications.ToList();
list.Add(new Notifications(user.Email, model.Article, "Classi"));
userToBeNotify.Notifications = list;
_writeOnlyRepository.Update(userToBeNotify);
}
}
//check
MessageBox.Show("Classified added successfully");
}
return(View("CreateClassified", model));
}
public ActionResult Login(AccountLoginModel login, string returnUrl)
{
if (ModelState.IsValid)
{
var user = _readOnlyRepository.FirstOrDefault <AccountLogin>(x => x.Email == login.Email && x.Password == (new Hasher().Encrypt(login.Password)) && !x.Archived);
if (user != null)
{
FormsAuthentication.SetAuthCookie(login.Email, login.RememberMe);
SetAuthenticationCookie(login.Email, user.Role);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
//JUST to avoid LazyInitialization
var userAux = new AccountLogin();
userAux.AccountMessages = user.AccountMessages;
userAux.Notifications = user.Notifications;
Session["User"] = null;
Session["User"] = user;
return(RedirectToAction("ToInbox"));
}
ModelState.AddModelError("", "The user name or password provided is incorrect or not active.");
}
return(View(login));
}