public async Task <IActionResult> Details(int id)
{
try
{
var addressTypeViewModel = await _iAddressManager.GetAddressEntityAsync(id);
var model = _iMapper.Map <AddressEntityViewModel, AddressEntityViewModel>(addressTypeViewModel);
if (model != null)
{
return(View("Details", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Details[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
public async Task <IActionResult> DeleteAddress(int id)
{
Result result = new Result();
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("DeleteAddress[POST]"));
if (id > 0)
{
result = await _iAddressManager.DeleteAddressEntityAsync(id);
}
else
{
result = Result.Fail(MessageHelper.DeleteFail);
}
if (result.Success)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "DeleteAddress[POST]"));
result = Result.Fail(MessageHelper.UnhandelledError);
return(BadRequest(result));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Delete(int id)
{
try
{
if (id > 0)
{
_result = await _iAddressManager.DeleteAddressEntityAsync(id);
}
else
{
_result = Result.Fail(MessageHelper.DeleteFail);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Delete, "AddressMessage");
}
else
{
this.FlashError(_result.Error, "AddressMessage");
}
return(JsonResult(_result));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Delete[POST]"));
_result = Result.Fail(MessageHelper.UnhandelledError);
return(JsonResult(_result));
}
}
public async Task <IActionResult> Add()
{
try
{
var model = new AddressEntityViewModel();
if (model != null)
{
ViewBag.CountryList = await _iAddressManager.GetCountryEntitysAsync();
ViewBag.StateList = await _iAddressManager.GetStateEntitysAsync();
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Add[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
/// <summary>
/// 请求的返回函数
/// </summary>
/// <param name="retCode">返回代码:-9:异常,-5:没有权限,-3:未登陆,-1:没有数据,0:执行成功</param>
/// <param name="retMsg">返回信息:字符串(如果是Json字符串自动解析)</param>
public void Ret(int retCode, string retMsg)
{
if (g_IsAjax)
{
// Response.Write(Json.WriteRaw(retCode, retMsg));
if (retCode == -3)
{
string login = "******";
Response.Write(login);
Response.End();
return;
}
}
else if (Request.RawUrl.ToLower() == "/prowebequactive/default.aspx" && retCode == -3)
{
Response.Redirect("/prowebequactive/login.aspx?type=-3&msg=" + retMsg, true);
LogMessageHelper.LogINFO("尝试访问未登录系统。");
}
else
{
Response.Redirect("/prowebequactive/errpage.aspx?type=" + retCode + "&msg=" + retMsg, true);
}
Response.Flush();
Response.Clear();
}
internal IActionResult ErrorNullPartialView()
{
ErrorPageViewModel errorPageViewModel = new ErrorPageViewModel();
errorPageViewModel.ErrorMessage = MessageHelper.NullError;
errorPageViewModel.ErrorType = MessageHelper.MessageTypeDanger;
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
internal IActionResult ErrorPartialView(Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ErrorPartialView"));
var errorPageViewModel = new ErrorPageViewModel();
errorPageViewModel = ExceptionHelper.ExceptionErrorMessageFormat(ex);
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("ResetPassword[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
bool isValid = true;
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
isValid = false;
// Don't reveal that the user does not exist
ModelState.AddModelError(string.Empty, "Invalid email.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ResetPassword[POST]", $"Invalid email, UserEmail: {model.Email}"));
return(View(model));
}
//var isEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
//if (!isEmailConfirmed)
//{
// isValid = false;
// // Don't reveal that the user email is not confirmed
// ModelState.AddModelError(string.Empty, "Email is not confirmed.");
// _log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ResetPassword[POST]", $"Email is not confirmed, UserEmail: {model.Email}"));
// return View(model);
//}
if (isValid)
{
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(View("ResetPasswordConfirmation"));
}
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ResetPassword[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("ForgotPassword[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
bool isValid = true;
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
isValid = false;
// Don't reveal that the user does not exist
ModelState.AddModelError(string.Empty, "Invalid email.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ForgotPassword[POST]", $"Invalid email, UserEmail: {model.Email}"));
return(View(model));
}
//var isEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
//if (!isEmailConfirmed)
//{
// isValid = false;
// // Don't reveal that the user email is not confirmed
// ModelState.AddModelError(string.Empty, "Email is not confirmed.");
// _log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ForgotPassword[POST]", $"Email is not confirmed, UserEmail: {model.Email}"));
// return View(model);
//}
if (isValid)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
var message = await GenareteForgotPasswordEmailTemplateAsync(user);
//await _emailSender.SendEmailBySendGridAsync(user.Id, model.Email, "Reset Password", message);
return(View("ForgotPasswordConfirmation"));
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ForgotPassword[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Logout()
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("LogOff", $"User:{User.Identity.Name}"));
await _signInManager.SignOutAsync();
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("LogOff", $"User logged out"));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "LogOff"));
}
return(RedirectToAction("Login", "Account"));
}
public async Task <IActionResult> GetAddress(int id)
{
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("GetAddress[GET]"));
var response = await _iAddressManager.GetAddressEntityAsync(id);
return(Ok(response));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "GetAddress[GET]"));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Save(AddressEntityViewModel viewModel)
{
try
{
ViewBag.CountryList = await _iAddressApiService.GetAllCountryAsync();
ViewBag.StateList = await _iAddressApiService.GetAllStateAsync();
if (ModelState.IsValid)
{
//add
if (viewModel.AddressId == 0)
{
_result = await _iAddressManager.InsertAddressEntityAsync(viewModel);
}
else if (viewModel.AddressId > 0) //edit
{
_result = await _iAddressManager.UpdateAddressEntityAsync(viewModel);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Save, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
else
{
this.FlashError(_result.Error, "AddressMessage");
return(View("AddOrEdit", viewModel));
}
}
else
{
this.FlashError(ExceptionHelper.ModelStateErrorFirstFormat(ModelState), "AddressMessage");
return(View("AddOrEdit", viewModel));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Save[POST]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(View("AddOrEdit", viewModel));
}
public async Task <IActionResult> SaveAddress(AddressEntityViewModel viewModel)
{
Result result = new Result();
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("AddAddress[POST]"));
if (ModelState.IsValid)
{
//add
if (viewModel.AddressId == 0)
{
result = await _iAddressManager.InsertAddressEntityAsync(viewModel);
}
else if (viewModel.AddressId > 0) //edit
{
result = await _iAddressManager.UpdateAddressEntityAsync(viewModel);
}
if (result.Success)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
else
{
var modelStateError = ExceptionHelper.ModelStateErrorFirstFormat(ModelState);
result = Result.Fail(modelStateError);
return(BadRequest(result));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "AddAddress[POST]"));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Save(AddressTypeViewModel viewModel)
{
try
{
if (ModelState.IsValid)
{
//add
if (viewModel.TypeId == 0)
{
_result = await _iAddressTypeManager.InsertAddressTypeAsync(viewModel);
}
else if (viewModel.TypeId > 0) //edit
{
_result = await _iAddressTypeManager.UpdateAddressTypeAsync(viewModel);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Save, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
else
{
this.FlashError(_result.Error, "AddressTypeMessage");
return(View(viewModel));
}
}
else
{
this.FlashError(ExceptionHelper.ModelStateErrorFirstFormat(ModelState), "AddressTypeMessage");
return(View(viewModel));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Save[POST]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(View(viewModel));
}
private async Task <Result> IsEmailExists(ApplicationUser user)
{
try
{
var isExists = await _userManager.FindByEmailAsync(user.Email);
if (isExists != null)
{
string isEmailExistsMessage = string.Format(MessageHelper.IsEmailExists, user.Email);
return(Result.Fail(isEmailExistsMessage));
}
else
{
return(Result.Ok());
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "IsEmailExists"));
return(Result.Fail(MessageHelper.Error));
}
}
public IActionResult Add()
{
try
{
var model = new AddressTypeViewModel();
if (model != null)
{
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Add[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
/// <summary>
/// 检查License并返回相关值
/// </summary>
/// <param name="licenseFilePath">License文件的路径</param>
/// <returns>字符串数组:[返回值标识,应用程序标识, 使用截止日期]
/// 返回值标识: -1:日期过期
/// -2:授权码错误
/// -9：系统错误
/// 0：正确返回
/// </returns>
public static string[] CheckLicense(string licenseFilePath)
{
try
{
string text = FileHelper.GetFileText(licenseFilePath);
string[] texts = text.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
// 判断授权是否过期
DateTime dtSrc = Tools.GetDateTime(texts[1], DateTime.Now.AddYears(-100));
DateTime dtNow = DateTime.Now;
// 授权过期
if (dtSrc.AddDays(1) < dtNow)
{
return new string[] { "-1", "-1", "" }
}
; //
// 判断密钥串是否正确 + texts[2] + "\r\n"
string keyMust = Tools.GetMD5Str(texts[0] + "\r\n" + texts[1] + "\r\n" + Consts.KEY_SECRETSTR);
// 授权码错误
if (keyMust != texts[2])
{
return new string[] { "-2", "-2", "" }
}
; //
return(new string[] { "0", texts[0], texts[1] }); // , texts[2]
}
catch (Exception ex)
{
Dictionary <string, string> logParms = new Dictionary <string, string>();
logParms["licenseFilePath"] = licenseFilePath;
//系统错误[日志]
LogMessageHelper.LogINFO("检查License出错", logParms, null, ex);
return(new string[] { "-9", "-3", "" });//"-3",
}
}
public async Task <IActionResult> Edit(int id)
{
try
{
var model = await _iAddressTypeManager.GetAddressTypeAsync(id);
if (model != null)
{
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Edit[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
/// <summary>
/// 执行命令或存储过程
/// </summary>
/// <param name="cmd">命令对象</param>
/// <returns></returns>
public virtual T Execute <T>(OracleCommand cmd)
{
object retval = default(T); // 返回值
Type type = typeof(T); // 返回值类型
try
{
// 关联事务,若为空,则不使用事务操作
cmd.Transaction = _Tran;
// 根据返回值类型来判断调用哪个方法
if (type == typeof(int))
{
// 只返回影响行数
retval = cmd.ExecuteNonQuery();
// retval = cmd.ExecuteOracleNonQuery(
}
else if (type == typeof(DataSet))
{
// 返回DataSet
DataSet ds = new DataSet();
using (OracleDataAdapter da = new OracleDataAdapter(cmd))
{
da.Fill(ds);
}
retval = ds;
}
else if (type == typeof(DataTable))
{
// 返回DataTable
DataTable dt = new DataTable();
using (OracleDataAdapter da = new OracleDataAdapter(cmd))
{
da.Fill(dt);
}
retval = dt;
}
else if (type == typeof(OracleDataReader))
{
// 返回OracleDataReader
retval = cmd.ExecuteReader();
}
else if (type == typeof(object))
{
// 返回第一个值
retval = cmd.ExecuteScalar();
}
else
{
LogMessageHelper.LogERROR(string.Format("The type({0}) is not supported", type));
throw new Exception(string.Format("The type({0}) is not supported", type));
}
// 清除命令
cmd.Parameters.Clear();
}
catch (OracleException ex)
{
//记录数据库执行错误日志
StringBuilder parsdb = new StringBuilder();
parsdb.Append("{");
foreach (OracleParameter par in cmd.Parameters)
{
parsdb.AppendFormat("{0}:{1}", par.ParameterName, par.Value);
}
parsdb.Append("}");
Dictionary <string, string> pars = new Dictionary <string, string>();
pars.Add("command", cmd.CommandText);
pars.Add("type", cmd.CommandType.ToString());
pars.Add("pars", parsdb.ToString());
LogMessageHelper.LogERROR("数据库执行错误", pars, null, ex);
//重新抛出异常
throw ex;
}
finally
{
// 是否要关闭连接
if (type != typeof(OracleDataReader))
{
if (_mustColseConnection == true)
{
_conn.Close();
_conn = null;
}
}
}
// 返回值
return((T)retval);
}
internal IActionResult ErrorPartialView(ErrorPageViewModel errorPageViewModel)
{
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
internal IActionResult JsonResult(Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "JsonResult"));
return(ModalHelper.JsonError(ex));
}
internal IActionResult JsonResult(Result result)
{
_log.Error(LogMessageHelper.FormateMessageForException(result.Error, "JsonResult"));
return(ModalHelper.Json(result));
}
public async Task <IActionResult> Login(LoginViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("Login[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
ApplicationUser user = await _userManager.FindByNameAsync(model.Email);
if (user != null)
{
await _signInManager.SignOutAsync();
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
//var data = await GetUserSignInOutHistoryLocal(model);
//await _userLogInOutHistoryManager.CreateLogInOutHistoryAsync(data);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"User logged in, UserEmail: {model.Email}"));
var isAdmin = await _userManager.IsInRoleAsync(user, AppConstants.AppUserRole.Admin);
if (isAdmin)
{
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(RedirectToAction("Index", "Admin"));
}
return(Redirect(model.ReturnUrl));
}
else
{
return(RedirectToLocal(model.ReturnUrl));
}
}
if (result.IsLockedOut)
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"User account locked out, UserEmail: {model.Email}"));
return(View("Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"Invalid login attempt, UserEmail: {model.Email}"));
return(View(model));
}
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Login[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("Register[POST]"));
if (ModelState.IsValid)
{
string userName = ((model.Email).Split('@')[0]).Trim(); // you are get here username.
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email
};
_result = await IsEmailExists(user);
if (!_result.Success)
{
ModelState.AddModelError(string.Empty, _result.Error);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", _result.Error));
return(View(model));
}
var role = new ApplicationRole
{
Id = model.RoleName,
Name = model.RoleName,
IsActive = true
};
IdentityResult resultRole = await _roleManager.CreateAsync(role);
if (resultRole.Succeeded)
{
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, model.RoleName);
await _signInManager.SignInAsync(user, isPersistent : false);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", $"User created a new account with password, UserEmail:{model.Email}"));
var isAdmin = await _userManager.IsInRoleAsync(user, AppConstants.AppUserRole.Admin);
if (isAdmin)
{
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(RedirectToAction("Index", "Admin"));
}
return(Redirect(model.ReturnUrl));
}
else
{
return(RedirectToLocal(model.ReturnUrl));
}
}
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", $"User creation failed, UserEmail:{model.Email}"));
AddErrors(result);
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Register[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
