public ActionResult Register(RegisterModel model)
{
throw new NotImplementedException();
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
ViewBag.PasswordLength = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
MigrateShoppingCart(model.UserName);
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
Roles.AddUserToRole(model.UserName, "Responsable");
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Index", "Acciones"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult LogOn(LogOnVM datosUsuario, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(datosUsuario.UserName, datosUsuario.Password))
{
FormsService.SignIn(datosUsuario.UserName, datosUsuario.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
var usuario = uow.Users.Consulta(a => a.Name == datosUsuario.UserName).SingleOrDefault();
if (usuario != null)
{
Session["Usuario"] = usuario.Name;
}
return(RedirectToAction("Index", Session["Usuario"] != null ? "UserManagement" : "AdvertisersManagement"));
}
ModelState.AddModelError("", "El nombre de usuario o la contraseña son incorrectos.");
}
// If we got this far, something failed, redisplay form
return(View(datosUsuario));
}
public ActionResult Enable(string code)
{
var customer = Services.ServiceContext.CustomerService.GetAll().Where(p => p.ActivateKey == new Guid(code)).FirstOrDefault();
if (customer != null)
{
MembershipUser user = Membership.GetUser(customer.UserName, true);
user.IsApproved = true;
Membership.UpdateUser(user);
customer.ModifyDate = DateTime.Now;
customer.ModifiedBy = customer.UserName;
customer.Status = (short)Model.InfraStructure.Enums.StatusType.Active;
Services.ServiceContext.CustomerService.Update(customer);
FormsService.SignIn(customer.UserName, true);
this.TempData["Message"] = Internationalization.Label.User_Activated_Successfully;
return(RedirectToAction("/create", "customer", new { id = customer.IDCustomer }));
}
else
{
this.TempData["Message"] = Internationalization.Label.User_ActivateCode_Not_Exists;
return(View());
}
}
public ActionResult LogOn(AccountModel model)
{
if (!ModelState.IsValid)
{
string scriptId = "signin";
ViewData.Model = scriptId;
ViewData.Model = new AccountModel(new LogOnModel());
return(View());
}
ViewData.Model = new AccountModel(model.LogonModel);
var userValid = userModule.Authenticate(new User()
{
UserName = model.LogonModel.UserName, Password = model.LogonModel.Password
});
if (userValid)
{
Session.Refresh(HttpContext);
HttpCookie providerCookie = new HttpCookie("SkynerCookie");
var provider = providerModule.GetProvider(Session.User.ProviderId);
if (provider != null)
{
providerCookie.Value = provider.Name;
}
Response.Cookies.Add(providerCookie);
ViewData["UserName"] = Session.User.UserName;
FormsService.SignIn(model.LogonModel.UserName, model.LogonModel.RememberMe);
Session.SessionEndTime = DateTime.Now;
return(Redirect(Url.Home()));
}
return(View());
}
public ActionResult Register(RegisterModel model)
{
// clear validation because username is not provided
ModelState.Clear();
// set hte username to the email
model.UserName = model.Email.ToLower();
var ctx = new ValidationContext(model, null, null);
var rst = new List <ValidationResult>();
Validator.TryValidateObject(model, ctx, rst);
foreach (var a in rst)
{
ModelState.AddModelError(a.MemberNames.First(), a.ErrorMessage);
}
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Index", "InformationRequest"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
ViewBag.PasswordLength = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult Login(AccountModel account)
{
//Redirect user to home page if already is Authenticated state
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Home"));
}
//check email existence in CRM
account = dm.ValidateUser(account);
if (account != null)
{
FormsService.SignIn(account.AccountId.ToString(), account.Name, account.Email);
Session["LoggedInUser"] = account;
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect or No user exists against provided email address");
}
// If we got this far, something failed, redisplay form
return(View(account));
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
foreach (string file in Request.Files)
{
HttpPostedFileBase hpf = Request.Files[file] as HttpPostedFileBase;
if (hpf.ContentLength == 0)
{
continue;
}
ProfileBase pb = ProfileBase.Create(model.UserName, true);
Uri geller = AvatarManager.Save(model.UserName, hpf.InputStream);
pb["AvatarUri"] = geller.ToString();
ResizeRequestManager.AddResizeRequest(geller);
pb.Save();
}
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
List <ICriterion> Crit = new List <ICriterion>();
Crit.Add(Restrictions.Eq("username", model.UserName));
User user = new UserService().FindByCriteria(Crit);
string username = string.Empty;
if (user != null)
{
username = user.username;
}
if (MembershipService.ValidateUser(username, model.Password))
{
FormsService.SignIn(username, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult LogOnByUserName(LogOnByUserNameModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
Session["ContentLength"] = null;
Session["ContentType"] = null;
Session["ContentStream"] = null;
Session["CurrentUser"] = MembershipService.GetUser(model.UserName);
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult LogOn(Models.LogOnModel data)
{
try
{
if (data.UserName.Contains("@"))
{
if ((data.UserName = MembershipService.GetUserNameByEmail(data.UserName)) == null)
{
ModelState.AddModelError("", "用户名 或 密码不正确");
Response.StatusCode = 406;
return(null);
}
}
if (MembershipService.ValidateUser(data.UserName, data.Password))
{
FormsService.SignIn(data.UserName, data.RememberMe);
Response.StatusCode = 200;
return(null);
}
else
{
ModelState.AddModelError("", "用户名 或 密码不正确");
}
Response.StatusCode = 406;
return(null);
}
catch
{
Response.StatusCode = 500;
return(null);
}
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Register(RegisterModel model)
{
model.Password = Encoder.HtmlEncode(model.Password);
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{
byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(model.UserName);
byte[] result;
SHA1 shaM = new SHA1Managed();
result = shaM.ComputeHash(toEncodeAsBytes);
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
//Encode the username in base64
HttpCookie authCookie = new HttpCookie("username", System.Text.ASCIIEncoding.ASCII.GetString(result));
HttpContext.Response.Cookies.Add(authCookie);
//byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(model.UserName);
//HttpCookie authCookie = new HttpCookie("username", System.Convert.ToBase64String(toEncodeAsBytes));
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
ViewBag.PasswordLength = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
FormsService.SignIn(model.UserName, false);
var accountNumber = "";
var oldUser = MembershipService.GetUser(model.UserName, false);
var userID = oldUser.ProviderUserKey.ToString();
using (ATMEntities db = new ATMEntities())
{
var customer = from c in db.customers
where c.idCustomer == userID
select c;
accountNumber = customer.Single().account;
}
Session.Add("accountNumber", accountNumber);
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
return(View(model));
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{ // On success create a new customer data
MembershipUser newUser = MembershipService.GetUser(model.UserName, false);
string newUserID = newUser.ProviderUserKey.ToString();
string dtStamp = DateTime.Now.ToString();
string accountNo = Guid.NewGuid().ToString();
var dbATM = new ATMEntities();
var customer = new customer
{
idCustomer = newUserID,
firstName = model.FirstName,
lastName = model.LastName,
account = accountNo,
cDate = dtStamp
};
dbATM.customers.AddObject(customer);
dbATM.SaveChanges();
FormsService.SignIn(model.UserName, false);
Session.Add("accountNumber", accountNo);
TempData["justRegistered"] = "Y";
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", CustomerValidation.ErrorCodeToString(createStatus));
}
}
ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
return(View(model));
}
public JsonResult UserLogForWinCE(FormCollection collection)
{
//Language lang;
var service = new SysUserService();
SysUser user = service.Login(collection["UserName"], collection["Password"]);
if (user == null || string.Compare(user.Pwd, collection["Password"], false) != 0)
{
return(Json(new { success = false, msg = "<=PwdorNameError>" }));
}
else
{
DateTime dt = DateTime.Today;
if (!(user.ValidDateFrom <= dt && user.ValidDateTo >= dt) || !user.Active)
{
return(Json(new { success = false, msg = "<=UserExpireError>" }));
}
FormsService.SignIn(collection["UserName"], false);
//lang = (Language)int.Parse(collection["Lang"]);
//Response.Cookies["Lang"].Value = lang == Language.English ? "English" : "SimplifiedChinese";
//Response.Cookies["Lang"].Expires = DateTime.Now.AddDays(365);
return(Json(new { success = true, msg = "<=LoginSuccess>" }));
}
}
// **************************************
// URL: /Account/AutoLogIn
// **************************************
// TODO: inactivate this action when publish
public ActionResult AutoLogInOnlyEditor(string returnUrl)
{
IUserContext userContext = CoreData.UserManager.Login("Testuseronlyeditor", "TestUser11", Resources.DyntaxaSettings.Default.DyntaxaApplicationIdentifier);
if (userContext.IsNotNull())
{
Session["userContext"] = userContext;
userContext.Locale = CoreData.LocaleManager.GetLocale(userContext, LocaleId.en_GB);
// Must clear the service cash so that roles can be reloded.
// CoreData.TaxonManager.ClearCacheForUserRoles(userContext);
/* globalization with cookie */
HttpCookie cookie = new HttpCookie("CultureInfo");
cookie.Value = userContext.Locale.ISOCode;
cookie.Expires = DateTime.Now.AddYears(1);
Response.Cookies.Add(cookie);
Thread.CurrentThread.CurrentUICulture = userContext.Locale.CultureInfo;
Thread.CurrentThread.CurrentCulture = userContext.Locale.CultureInfo;
FormsService.SignIn("Testuseronlyeditor");
this.RedrawTree();
}
else
{
ModelState.AddModelError("", Resources.DyntaxaResource.AccountControllerIncorrectLoginError);
}
if (string.IsNullOrEmpty(returnUrl))
{
return RedirectToAction("SearchResult", "Taxon");
}
return Redirect(returnUrl);
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Попытка зарегистрировать пользователя
MembershipCreateStatus status;
new DataManager(_session).MembershipRepository.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out status);
if (status == MembershipCreateStatus.Success)
{
FormsService.SignIn(model.UserName, false /* createPersistentCookie */);
return(RedirectToAction("Edit", "User"));
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(status));
}
}
// Появление этого сообщения означает наличие ошибки; повторное отображение формы
ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
return(View(model));
}
public ActionResult LogOnByPhoto(LogOnByPhotoModel model, string returnUrl)
{
model.PhotoStream = (byte[])Session["ContentStream"];
string userName = null;
double runTime = -1;
try
{
if (MembershipService.ValidateUser(model.PhotoStream, out userName, model.Algorithm, out runTime))
{
model.UserName = userName;
Session["CurrentUser"] = MembershipService.GetUser(model.UserName);
Session["LastRecognitionAlgorithm"] = Enum.GetName(typeof(support.Algorithm), model.Algorithm);
Session["LastRecognitionTime"] = runTime;
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
}
catch
{ }
finally
{
Session["ContentLength"] = null;
Session["ContentType"] = null;
Session["ContentStream"] = null;
}
ModelState.AddModelError("", "The user not found.");
//Response.BinaryWrite((byte[])Session["ContentStream"]);
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult MobileLogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (model.RememberMe)
{
Response.Cookies["UserName"].Value = model.UserName;
Response.Cookies["Password"].Value = model.Password;
Response.Cookies["UserName"].Expires = DateTime.Now.AddMonths(12);
Response.Cookies["Password"].Expires = DateTime.Now.AddMonths(12);
}
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
Response.Cookies["UserName"].Expires = DateTime.Now.AddMonths(-1);
Response.Cookies["Password"].Expires = DateTime.Now.AddMonths(-1);
ViewData["UserNamePassError"] = ViewRes.Controllers.Account.UserNamePassError;
}
}
// If we got this far, something failed, redisplay form
return(View("/Views/Home/Index.Mobile.aspx", model));
}
public ActionResult LogOn(string logOnKey)
{
UserLoginInfo userLoginInfo = (new JavaScriptSerializer()).Deserialize <UserLoginInfo>(Des.DecryptDES(logOnKey, "12345678"));
string userName = userLoginInfo.UserName;
string password = userLoginInfo.Password;
string cityId = userLoginInfo.CityID;
string systemId = userLoginInfo.SystemID;
string serverId = userLoginInfo.ServerID;
bool bResult = UserService.ValidateUser(userName, password) &&
UserService.ValidateUserPermission(userName, cityId, systemId);
if (bResult)
{
FormsService.SignIn(userName, false);
this.AddCookie("cityid", cityId);
this.AddCookie("systemid", systemId);
this.AddCookie("serverid", serverId);
this.AddCookie("username", userName);
// LoginLogService.Add(userName, systemId);
}
return(new RedirectToRouteResult(new RouteValueDictionary {
{ "controller", "Home" }
}));
}
public ActionResult LogOff()
{
FormsService.SignOut();
return(RedirectToAction("Index", "Home"));
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
Session["Gridresult"] = null;
try
{
if (ModelState.IsValid)
{
var data = uow.Context.UserInformations.SingleOrDefault(f => f.UserName == model.UserName);
if (data == null)
{
ModelState.AddModelError("", "The user name not found.");
return(View(model));
}
if (data.IsApproved)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
if (data != null)
{
if (data.USERTYPE == "D")
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
Session["DoctorId"] = User.Identity.Name;
UserLoginsUnitOfWork uluow = new UserLoginsUnitOfWork();
using (var repo = new UserLoginsServiceRepository(uluow))
{
USERLOGIN temp = new USERLOGIN();
temp.LOGINTIME = DateTime.UtcNow;
temp.DateCreated = DateTime.UtcNow;
temp.CREATEDBY = model.UserName;
temp.UserName = model.UserName;
temp.STATUS = "A";
temp.MODIFIEDBY = model.UserName;
temp.MODIFIEDON = DateTime.UtcNow;
temp.State = State.Added;
repo.InsertOrUpdate(temp);
uluow.Save();
}
if (data.IsfirstLogin.Trim() == "false")
{
return(RedirectToAction("Dashboard", "DoctorInformation"));
}
else
{
return(RedirectToAction("Welcomepage", "DoctorInformation"));
}
}
}
else if (data.USERTYPE == "P")
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
Session["PatientId"] = User.Identity.Name;
UserLoginsUnitOfWork uluow = new UserLoginsUnitOfWork();
using (var repo = new UserLoginsServiceRepository(uluow))
{
USERLOGIN temp = new USERLOGIN();
temp.LOGINTIME = DateTime.UtcNow;
temp.DateCreated = DateTime.UtcNow;
temp.CREATEDBY = model.UserName;
temp.UserName = model.UserName;
temp.STATUS = "A";
temp.MODIFIEDBY = model.UserName;
temp.MODIFIEDON = DateTime.UtcNow;
temp.State = State.Added;
repo.InsertOrUpdate(temp);
uluow.Save();
}
if (data.IsfirstLogin.Trim() == "false")
{
return(RedirectToAction("Dashboard", "PatientProfile"));
}
else
{
return(RedirectToAction("Welcomepage", "PatientProfile"));
}
}
}
else if (data.USERTYPE == "A")
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("AccountAdmin", "AccountSettings"));
}
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
else
{
ModelState.AddModelError("", "Please Activate your account from your Email-id doccare registration message.");
}
}
}
catch (Exception ex)
{
throw new CustomException("Exception:- Project: {0} \n Error Message: {1} ", ex.InnerException, new Object[] { ex.Source, ex.Message });
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public JsonResult LogOnOuter(LogOnModel model, string returnUrl)
{
Session["Gridresult"] = null;
try
{
if (ModelState.IsValid)
{
var data = uow.Context.UserInformations.SingleOrDefault(f => f.UserName == model.UserName);
if (data == null)
{
return(Json(new { msg = "The user name not found" }, JsonRequestBehavior.AllowGet));
}
if (data.IsApproved)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
if (data != null)
{
if (data.USERTYPE == "P")
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (true)
{
UserLoginsUnitOfWork uluow = new UserLoginsUnitOfWork();
using (var repo = new UserLoginsServiceRepository(uluow))
{
Session["PatientID"] = model.UserName;
USERLOGIN temp = new USERLOGIN();
temp.LOGINTIME = DateTime.UtcNow;
temp.DateCreated = DateTime.UtcNow;
temp.CREATEDBY = model.UserName;
temp.UserName = model.UserName;
temp.STATUS = "A";
temp.MODIFIEDBY = model.UserName;
temp.MODIFIEDON = DateTime.UtcNow;
temp.State = State.Added;
repo.InsertOrUpdate(temp);
uluow.Save();
}
}
}
else
{
return(Json(new { msg = "Account type not valid" }, JsonRequestBehavior.AllowGet));
}
}
}
else
{
return(Json(new { msg = "The user name or password provided is incorrect." }, JsonRequestBehavior.AllowGet));
}
}
else
{
return(Json(new { msg = "Please Activate your account from your Email-id doccare registration message." }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
throw new CustomException("Exception:- Project: {0} \n Error Message: {1} ", ex.InnerException, new Object[] { ex.Source, ex.Message });
}
return(Json(new { msg = "success" }, JsonRequestBehavior.AllowGet));
}
public virtual ActionResult Authenticate(string openid_provider)
{
var openid = new OpenIdRelyingParty();
var response = openid.GetResponse();
Logger.InfoFormat("Trying to log-on user using OpenId Identifier: {0} .", openid_provider);
if (response == null)
{
var request = openid.CreateRequest(openid_provider);
var claim = new ClaimsRequest
{
Email = DemandLevel.Require,
Nickname = DemandLevel.Require,
FullName = DemandLevel.Request,
};
var fetch = new FetchRequest();
fetch.Attributes.AddRequired(WellKnownAttributes.Name.First);
fetch.Attributes.AddRequired(WellKnownAttributes.Name.Last);
request.AddExtension(claim);
request.AddExtension(fetch);
return(request.RedirectingResponse.AsActionResult());
}
if (response.Status == AuthenticationStatus.Authenticated)
{
var claim = response.GetExtension <ClaimsResponse>();
var fetch = response.GetExtension <FetchResponse>();
var nick = response.FriendlyIdentifierForDisplay;
var email = string.Empty;
if (claim != null)
{
nick = string.IsNullOrEmpty(claim.Nickname) ? claim.FullName : claim.Nickname;
email = claim.Email;
}
if (string.IsNullOrEmpty(nick) && fetch != null &&
fetch.Attributes.Contains(WellKnownAttributes.Name.First) &&
fetch.Attributes.Contains(WellKnownAttributes.Name.Last))
{
nick = fetch.GetAttributeValue(WellKnownAttributes.Name.First) + " " +
fetch.GetAttributeValue(WellKnownAttributes.Name.Last);
}
var user = string.Format("{0} <{1}>", nick, email);
FormsService.SignIn(user);
Logger.InfoFormat("User {0} authenticated successfully.", user);
return(RedirectToAction("Index", "Home"));
}
Logger.Warn("User attempted login but password validation failed.");
ModelState.AddModelError("", "Authentication failed.");
return(View("LogOn"));
}
public ActionResult LogOff()
{
FormsService.SignOut();
Session.Remove(Strings.USER);
return(RedirectToAction("Index", "Reports"));
}
// **************************************
// URL: /Account/LogOff
// **************************************
public ActionResult LogOff()
{
FormsService.SignOut();
return(RedirectToAction("LogOn"));
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
int icount = db.aspnet_Users.Count();
if (icount == 0)
{
MembershipCreateStatus createStatus = MembershipService.CreateUser("admin", "123456", "系统管理员", Guid.Empty);
model.UserName = "******";
model.Password = "******";
}
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
//DXInfo.Models.ekey tk = null;
if (!string.IsNullOrEmpty(model.HardwareID))
{
using (DXInfo.Models.ynhnTransportManage context = new DXInfo.Models.ynhnTransportManage())
{
var key = context.ekey.Where(w => w.HardwareID == model.HardwareID).FirstOrDefault();
var us = context.aspnet_Users.Where(w => w.UserName == model.UserName).FirstOrDefault();
if (key == null)
{
DXInfo.Models.ekey tk = new ekey();
tk.HardwareID = model.HardwareID;
tk.CardNo = model.CardNo;
tk.CreateDate = DateTime.Now;
tk.IsUse = true;
tk.UserId = us != null ? us.UserId : Guid.Empty;
context.ekey.Add(tk);
context.SaveChanges();
}
else
{
if (!key.IsUse)
{
ModelState.AddModelError("", "提供的用户名或密码不正确。");
return(View(model));
}
}
}
}
FormsService.SignIn(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "提供的用户名或密码不正确。");
}
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
return(View(model));
}
// **************************************
// URL: /Account/LogOff
// **************************************
public ActionResult LogOff()
{
FormsService.SignOut();
return(Redirect(N2.Find.StartPage.Url));
}
private void ExecuteResponsesSearchTextTest(string[,] responsesFieldsValues, string searchedText, int expectedResultsCount)
{
var fieldsPerResponse = responsesFieldsValues.GetLength(1);
var controls = new MvcWidgetProxy[fieldsPerResponse];
for (int i = 0; i < controls.Length; i++)
{
var control = new MvcWidgetProxy();
control.ControllerName = typeof(TextFieldController).FullName;
var controller = new TextFieldController();
control.Settings = new ControllerSettings(controller);
controls[i] = control;
}
var formId = ServerOperationsFeather.Forms().CreateFormWithWidgets(controls);
var manager = FormsManager.GetManager();
var form = manager.GetForm(formId);
var masterDetailView = new FormsMasterDetailView();
masterDetailView.FormDescription = form;
var masterDetailDefinition = new MasterGridViewDefinition();
typeof(FormsMasterDetailView).GetMethod("ConfigureSearchFields", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(masterDetailView, new object[] { masterDetailDefinition });
var fields = masterDetailDefinition.SearchFields.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(fieldsPerResponse, fields.Length, string.Format(CultureInfo.InvariantCulture, "The produced search fields count ({0}) is not equal to the actual fields count on the form ({1})", fields.Length, fieldsPerResponse));
var service = new FormsService();
try
{
using (var fluent = App.WorkWith())
{
for (int responseIndex = 0; responseIndex < responsesFieldsValues.GetLength(0); responseIndex++)
{
var formEntry = fluent.Forms().Form(form.Name).Entry().CreateNew(Guid.NewGuid());
for (int fieldValueIndex = 0; fieldValueIndex < responsesFieldsValues.GetLength(1); fieldValueIndex++)
{
formEntry.SetFieldValue(fields[fieldValueIndex], responsesFieldsValues[responseIndex, fieldValueIndex]);
}
formEntry.SaveChanges();
}
}
var filterClauses = fields.Select(f => string.Format(CultureInfo.InvariantCulture, "{0}.ToUpper().Contains(\"{1}\".ToUpper())", f, searchedText));
var filter = "(" + string.Join(" OR ", filterClauses) + ")";
var entries = service.GetFormEntries(form.Name, null, "Title ASC", 0, 50, filter, manager.Provider.FormsNamespace + "." + form.Name, null, Guid.Empty);
Assert.AreEqual(expectedResultsCount, entries.TotalCount, string.Format(CultureInfo.InvariantCulture, "The returned search results ({0}) do not match the expected ones ({1})", entries.TotalCount, expectedResultsCount));
}
finally
{
FormsModuleCodeSnippets.DeleteForm(formId);
}
}
public TemplateForm GetForm(string clientId, string userId, int formId)
{
IFormsService formService = new FormsService();
var obForm = formService.GetForm(1, 1, 1);
var form = TemplateFormFactory.Create(obForm);
return form;
}
