public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
string str = "S" + DateTime.Now.ToString("yyyyMMdd");
InnerObject.OrderId = str + "-" + OrderService.GetOrderSerialnumber();
InnerObject.AccountId = AccountId;
InnerObject.Phone = Phone;
var user = SecurityHelper.GetCurrentUser();
InnerObject.Creater = user.CurrentUser.DisplayName;
InnerObject.CreaterId = user.CurrentUser.UserId;
InnerObject.createDate = DateTime.Now;
base.OnSave(InnerObject);
OrderService.CreateOrder(InnerObject);
foreach (var item in this.Detials)
{
item.OrderId = InnerObject.OrderId;
OrderService.AddOrderDetial(item);
}
AddMessage("success", InnerObject.OrderId);
Logger.LogWithSerialNo(LogTypes.AddOrder, serialNo, 0);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Edit()
{
var newObject = OrderService.QueryOrder(new Services.OrderRequest()
{
OrderId = InnerObject.OrderId
}).FirstOrDefault();
if (newObject != null)
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
//InnerObject.AccountId = AccountID;
//InnerObject.State = MyState;
//newObject.Address = Address;
newObject.Phone = AccountPhone;
//newObject.SubmitTime = DateTime.Now;
base.OnSave(newObject);
OrderService.UpdateOrder(newObject);
OrderService.DeleteOrderDetials(InnerObject.OrderId);
foreach (var item in this.Detials)
{
item.OrderId = OrderId;
OrderService.AddOrderDetial(item);
}
AddMessage("Edit.success", InnerObject.OrderId);
Logger.LogWithSerialNo(LogTypes.EditOrder, serialNo, InnerObject.Serialnumber, InnerObject.OrderId);
return(TransactionHelper.CommitAndReturn(this));
}
else
{
AddError(LogTypes.EditOrder, "无此订单！", null);
return(this);
}
}
public SimpleAjaxResult Save(int accountId)
{
try
{
var serialNo = SerialNoHelper.Create();
var passwordService = UnityContainer.Resolve <IPasswordService>(HostSite.PasswordType);
string password1, password2;
passwordService.Decrypto(this.Password, this.PasswordConfirm, out password1, out password2);
if (password1 != password2)
{
return(new SimpleAjaxResult(Localize("passwordNotEquals")));
}
Account account = AccountService.GetById(accountId);
if (account == null || (account.State != AccountStates.Normal && account.State != AccountStates.Invalid))
{
return(new SimpleAjaxResult(Localize("accountNoExisting")));
}
account.SetPassword(password1);
TransactionHelper.BeginTransaction();
AccountService.Update(account);
Logger.LogWithSerialNo(LogTypes.AccountChangePassword, serialNo, account.AccountId, AccountName);
AddMessage("success");
TransactionHelper.CommitAndReturn(this);
return(new SimpleAjaxResult());
}
catch (System.Exception ex)
{
Logger.Error(LogTypes.AccountChangePassword, ex);
return(new SimpleAjaxResult(ex.Message));
}
}
public bool AddOrder(ClientOrder order)
{
if (order.Detials.Any(x => x.Amount < 1) || order.Detials.Any(y => y.Price <= 0))
{
return(false);
}
try
{
OrderBase createOrder = new OrderBase();
createOrder.AccountId = order.AccountId;
createOrder.Address = order.Address;
createOrder.Creater = order.Creater;
createOrder.OrderId = GetOrderSerialnumber();
createOrder.State = OrderState.Normal;
createOrder.SubmitTime = DateTime.Now;
createOrder.TotalMoney = order.Detials.Sum(x => x.Amount * x.Price);
transactionHelper.BeginTransaction();
foreach (var item in order.Detials)
{
OrderDetialBase detial = new OrderDetialBase();
detial.Amount = item.Amount;
detial.GoodId = item.CommodityId;
detial.OrderId = createOrder.OrderId;
detial.price = item.Price;
_databaseInstance.Insert(detial, OrderTable);
}
_databaseInstance.Insert(createOrder, OrderDetialTable);
return(transactionHelper.CommitAndReturn(true));
}
catch
{ return(false); }
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
InnerObject.State = PointGiftStates.Normal;
HttpContext context = HttpContext.Current;
if (Photo != null && Photo.File != null)
{
var name = Guid.NewGuid().ToString("N") + ".jpg";
InnerObject.Photo = name;
var fileName = context.Server.MapPath("~/content/pointgiftphotos/" + name);
Moonlit.IO.DirectoryEnsure.EnsureFromFile(fileName);
Photo.File.SaveAs(fileName);
}
TransactionHelper.BeginTransaction();
base.OnSave(InnerObject);
PointGiftService.Create(InnerObject);
AddMessage("success", DisplayName);
Logger.LogWithSerialNo(LogTypes.PointGiftCreate, serialNo, InnerObject.PointGiftId, DisplayName);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
var roles = MembershipService.QueryRoles(new RoleRequest {
Name = RoleNames.ShopOwner
}).ToList();
TransactionHelper.BeginTransaction();
OnSave(InnerObject, Owner);
Owner.SetPassword(Password);
InnerObject.State = States.Normal;
InnerObject.RechargeAmount = RechargeAmount;
Owner.State = States.Normal;
ShopService.Create(InnerObject);
Owner.ShopId = InnerObject.ShopId;
MembershipService.CreateUser(Owner);
MembershipService.AssignRoles(Owner, roles.Select(x => x.RoleId).ToArray());
ShopDealLog log = new ShopDealLog(serialNo, DealTypes.Open, 0, null, null, null, InnerObject, 0);
ShopDealLogService.Create(log);
AddMessage("success", ShopName);
Logger.LogWithSerialNo(LogTypes.ShopCreate, serialNo, InnerObject.ShopId, ShopName);
CacheService.Refresh(CacheKeys.PosKey);
return(TransactionHelper.CommitAndReturn(this));
}
public object OpenReceipt(int id)
{
try
{
SystemDealLog dealLog = SystemDealLogService.GetById(id);
if (dealLog != null && !dealLog.HasReceipt && dealLog.DealType == SystemDealLogTypes.Recharge && dealLog.Amount > 0 && dealLog.State == SystemDealLogStates.Normal)
{
dealLog.HasReceipt = true;
TransactionHelper.BeginTransaction();
SystemDealLogService.Update(dealLog);
LogHelper.LogWithSerialNo(LogTypes.SystemDealLogOpenReceipt, SerialNoHelper.Create(), dealLog.SystemDealLogId, dealLog.SerialNo);
AddMessage(Localize("OpenReceipt.success"), dealLog.SystemDealLogId);
SendMessage(dealLog);
return(TransactionHelper.CommitAndReturn(new SimpleAjaxResult()));
}
return(new SimpleAjaxResult(Localize("OpenReceipt.failed", "原交易不存在")));
}
catch (Exception ex)
{
Logger.Error(LogTypes.SystemDealLogOpenReceipt, ex);
return(new SimpleAjaxResult(ex.Message));
}
}
public IMessageProvider Save()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var role = MembershipService.GetRoleById(InnerObject.RoleId);
if (role == null)
{
return(this);
}
role.DisplayName = DisplayName;
if (Users != null && !role.BuildIn)
{
var roleIds = Users.GetCheckedIds();
//role.Users = MembershipService.QueryUsers<User>(new UserRequest() { Ids = roleIds }).ToList();
MembershipService.DeleteUsersForRole(role.RoleId);
MembershipService.AssignUsers(role, roleIds);
}
var ids = this.Permissions.GetCheckedIds();
var permissions = PermissionService.QueryPermissions(this.UserType).Where(x => ids.Contains(x.PermissionId)).Select(x => x.Name).ToArray();
role.Permissions = string.Join(",", permissions);
MembershipService.UpdateRole(role);
this.Logger.LogWithSerialNo(LogTypes.RoleEdit, serialNo, role.RoleId, InnerObject.Name);
AddMessage("success", InnerObject.Name);
return(TransactionHelper.CommitAndReturn(this));
}
public object Save()
{
try
{
var serialNo = SerialNoHelper.Create();
SystemDealLog dealLog = SystemDealLogService.GetById(Id);
if (dealLog != null && dealLog.CanCancel(SystemDealLogTypes.Recharge, CurrentSite))
{
var account = AccountService.GetById(Convert.ToInt32(dealLog.Addin));
if (account == null || account.State != AccountStates.Normal)
{
return(new DataAjaxResult(Localize("NoAccount", "会员信息未找到")));
}
var passwordService = UnityContainer.Resolve <IPasswordService>(HostSite.PasswordType);
var password = passwordService.Decrypto(Password);
if (User.SaltAndHash(password, account.PasswordSalt) != account.Password)
{
return(new DataAjaxResult(Localize("error.Password", "密码错误")));
}
dealLog.State = SystemDealLogStates.Closed;
account.Amount -= dealLog.Amount;
var logItem = DealLogService.GetByAddin(dealLog.SystemDealLogId);
TransactionHelper.BeginTransaction();
if (logItem != null)
{
logItem.State = DealLogStates.Cancel;
DealLogService.Update(logItem);
DealLogService.Create(new DealLog(serialNo)
{
Account = account,
Amount = dealLog.Amount,
SubmitTime = DateTime.Now,
State = DealLogStates.Normal,
DealType = DealTypes.CancelRecharging,
Addin = logItem.DealLogId,
});
}
SystemDealLogService.Update(dealLog);
AccountService.Update(account);
LogHelper.LogWithSerialNo(LogTypes.SystemDealLogCloseRecharging, serialNo, dealLog.SystemDealLogId, dealLog.SystemDealLogId, account.Name);
AddMessage(Localize("CloseRecharging.success"), dealLog.SystemDealLogId);
return(TransactionHelper.CommitAndReturn(new SimpleAjaxResult()));
}
return(new SimpleAjaxResult(Localize("OpenReceipt.failed", "原交易不存在")));
}
catch (Exception ex)
{
Logger.Error(LogTypes.SystemDealLogCloseRecharging, ex);
return(new SimpleAjaxResult(ex.Message));
}
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
base.OnSave(InnerObject);
DealWayService.Create(InnerObject);
AddMessage("success", InnerObject.DisplayName);
Logger.LogWithSerialNo(LogTypes.DealWayCreate, serialNo, InnerObject.DealWayId, InnerObject.DisplayName);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
base.OnSave(InnerObject);
OrderService.CreateGood(InnerObject);
AddMessage("success", InnerObject.GoodName);
Logger.LogWithSerialNo(LogTypes.EditGood, serialNo, InnerObject.GoodId, InnerObject.GoodName);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Save()
{
TransactionHelper.BeginTransaction();
var serialNo = SerialNoHelper.Create();
var pointRebate = PointRebateService.GetById(this.PointRebate);
if (pointRebate == null)
{
AddError(LogTypes.AccountRebate, "NoPointRebate");
return(this);
}
var account = AccountService.GetById(AccountId);
if (account == null || account.Point < pointRebate.Point)
{
AddError(LogTypes.AccountRebate, "NoPointRebate");
return(this);
}
var accountLevel =
AccountLevelPolicyService.Query().FirstOrDefault(
x => x.State == AccountLevelPolicyStates.Normal && x.Level == account.AccountLevel && x.AccountTypeId == account.AccountTypeId);
var owner = (AccountUser)(_innerObject.OwnerId.HasValue ? this.MembershipService.GetUserById(_innerObject.OwnerId.Value) : null);
var pointRebates = PointRebateService.Query().Where(x => x.IsFor(account, owner, accountLevel, DateTime.Now) && x.Point < account.Point).ToList();
if (pointRebates.Count == 0)
{
AddError(LogTypes.AccountRebate, "NoPointRebate");
return(this);
}
if (!pointRebates.Any(x => x.PointRebateId == pointRebate.PointRebateId))
{
AddError(LogTypes.AccountRebate, "NoPointRebate");
return(this);
}
account.Amount += pointRebate.Amount;
account.Point -= pointRebate.Point;
AccountService.Update(account);
var dealLog = new DealLog(serialNo, DealTypes.Rebate, -pointRebate.Amount, -pointRebate.Point, null, null, account, null, pointRebate.PointRebateId);
DealLogService.Create(dealLog);
SystemDealLogService.Create(new SystemDealLog(serialNo, SecurityHelper.GetCurrentUser())
{
Amount = pointRebate.Amount, DealType = SystemDealLogTypes.Rebate, Addin = dealLog.DealLogId.ToString()
});
Logger.LogWithSerialNo(LogTypes.AccountRebate, serialNo, account.AccountId, account.Name, pointRebate.DisplayName);
PointRebateLogService.Create(new PointRebateLog(serialNo, account, SecurityHelper.GetCurrentUser().CurrentUser, pointRebate));
AddMessage("success", pointRebate.Amount, pointRebate.Point);
return(TransactionHelper.CommitAndReturn(this));
}
public SimpleAjaxResult Save()
{
if (Amount < 0)
{
return(new SimpleAjaxResult(Localize("invalidAmount")));
}
try
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var prePay = PrePayService.GetById(Id);
if (prePay != null && prePay.State == PrePayStates.Processing)
{
if (Amount == 0)
{
Amount = prePay.Amount;
}
var account = AccountService.GetById(prePay.AccountId);
if (account == null)
{
return(new SimpleAjaxResult(Localize("invalidAccount")));
}
var rsp = AccountDealService.DonePrePay(new PayRequest(prePay.AccountName, "", prePay.ShopName, Amount, serialNo,
account.AccountToken, prePay.ShopName, prePay.ShopName)
{
IsForce = true
});
if (rsp.Code != ResponseCode.Success)
{
return(new SimpleAjaxResult(ModelHelper.GetBoundText(rsp, x => x.Code)));
}
Logger.LogWithSerialNo(LogTypes.DonePrePayForce, serialNo, Id, account.Name);
DataAjaxResult r = new DataAjaxResult();
//if (!string.IsNullOrWhiteSpace(HostSite.TicketTemplateOfSuspendAccount))
//{
// r.Data1 = MessageFormator.FormatTickForSuspendAccount(HostSite.TicketTemplateOfSuspendAccount, HostSite,
// prePay, SecurityHelper.GetCurrentUser().CurrentUser);
// PrintTicketService.Create(new PrintTicket(LogTypes.AccountSuspend, r.Data1.ToString(), prePay));
//}
return(TransactionHelper.CommitAndReturn(r));
}
return(new SimpleAjaxResult(Localize("invalidDeal")));
}
catch (System.Exception ex)
{
Logger.Error(LogTypes.DonePrePayForce, ex);
return(new SimpleAjaxResult(ex.Message));
}
}
public SimpleAjaxResult Save()
{
try
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var account = AccountService.GetById(Id);
if (account != null && account.State == AccountStates.Invalid)
{
account.State = AccountStates.Normal;
AccountService.Update(account);
Logger.LogWithSerialNo(LogTypes.AccountResume, serialNo, Id, account.Name);
DataAjaxResult r = new DataAjaxResult();
if (!string.IsNullOrWhiteSpace(HostSite.MessageTemplateOfAccountResume))
{
var owner = account.OwnerId.HasValue ? MembershipService.GetUserById(account.OwnerId.Value) : null;
if (owner != null && owner.IsMobileAvailable)
{
var accountType = AccountTypeService.GetById(account.AccountTypeId);
if (accountType != null && accountType.IsSmsResume)
{
var msg = MessageFormator.Format(HostSite.MessageTemplateOfAccountResume, owner);
msg = MessageFormator.Format(msg, account);
SmsHelper.Send(owner.Mobile, msg);
}
}
}
if (!string.IsNullOrWhiteSpace(HostSite.TicketTemplateOfResumeAccount))
{
r.Data1 = MessageFormator.FormatTickForResumeAccount(
HostSite.TicketTemplateOfResumeAccount,
serialNo,
HostSite,
account,
account.OwnerId.HasValue ? MembershipService.GetUserById(account.OwnerId.Value) : null,
AccountTypeService.GetById(account.AccountTypeId),
SecurityHelper.GetCurrentUser().CurrentUser);
PrintTicketService.Create(new PrintTicket(LogTypes.AccountResume, serialNo, r.Data1.ToString(), account));
}
return(TransactionHelper.CommitAndReturn(r));
}
return(new SimpleAjaxResult(Localize("accountNoExisting")));
}
catch (System.Exception ex)
{
Logger.Error(LogTypes.AccountResume, ex);
return(new SimpleAjaxResult(ex.Message));
}
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
InnerObject.State = PointRebateStates.Normal;
TransactionHelper.BeginTransaction();
OnSave(InnerObject);
PointRebateService.Create(InnerObject);
AddMessage("success", DisplayName);
Logger.LogWithSerialNo(LogTypes.PointRebateCreate, serialNo, InnerObject.PointRebateId, DisplayName);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Create()
{
TransactionHelper.BeginTransaction();
var serialNo = SerialNoHelper.Create();
InnerObject.State = AccountLevelPolicyStates.Normal;
InnerObject.AccountTypeId = this.AccountType;
OnSave(InnerObject);
AccountLevelPolicyService.Create(InnerObject);
AddMessage("success", Level, DisplayName);
Logger.LogWithSerialNo(LogTypes.AccountLevelCreate, serialNo, Level, DisplayName);
CacheService.Refresh(CacheKeys.PointPolicyKey);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var ids = Permissions.GetCheckedIds();
var permissions = PermissionService.QueryPermissions(this.UserType).Where(x => ids.Contains(x.PermissionId)).Select(x => x.Name).ToArray();
InnerObject.Permissions = string.Join(",", permissions);
MembershipService.CreateRole(InnerObject);
this.Logger.LogWithSerialNo(LogTypes.RoleCreate, serialNo, InnerObject.RoleId, InnerObject.Name);
AddMessage("success", InnerObject.Name);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Save()
{
var serialNo = SerialNoHelper.Create();
var item = DealWayService.GetById(DealWayId);
if (item == null)
{
AddError(LogTypes.DealWayEdit, "nonFoundDealWay");
return(this);
}
TransactionHelper.BeginTransaction();
OnSave(item);
DealWayService.Update(item);
AddMessage("success" /*, InnerObject.DisplayName*/);
Logger.LogWithSerialNo(LogTypes.DealWayEdit, serialNo, InnerObject.DealWayId, InnerObject.DisplayName);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Save()
{
var serialNo = SerialNoHelper.Create();
var item = OrderService.GetById(GoodId);
if (item == null)
{
AddError(LogTypes.EditGood, "nonFoundGood");
return(this);
}
TransactionHelper.BeginTransaction();
OnSave(item);
OrderService.UpdateGood(item);
AddMessage("success", InnerObject.GoodName);
Logger.LogWithSerialNo(LogTypes.EditGood, serialNo, InnerObject.GoodId, InnerObject.GoodName);
return(TransactionHelper.CommitAndReturn(this));
}
public object Save()
{
var serialNo = SerialNoHelper.Create();
try
{
var account = AccountService.GetByName(AccountName);
if (account == null || account.State != AccountStates.Normal)
{
return(new DataAjaxResult(string.Format(Localize("NoAccount", "会员卡号 {0} 未找到"), AccountName)));
}
var passwordService = UnityContainer.Resolve <IPasswordService>(HostSite.PasswordType);
var password = passwordService.Decrypto(Password);
var accountLevel = AccountLevelPolicyService.Query().FirstOrDefault(x => x.Level == account.AccountLevel && account.AccountTypeId == x.AccountTypeId);
var owner = (AccountUser)(account.OwnerId.HasValue ? MembershipService.GetUserById(account.OwnerId.Value) : null);
var gift = PointGiftService.Query().Where(x => x.IsFor(account, owner, accountLevel, DateTime.Now)).FirstOrDefault(x => x.PointGiftId == GiftId);
if (gift == null)
{
return(new DataAjaxResult(Localize("NoGift", "礼品未找到")));
}
if (gift.Point > account.Point)
{
return(new DataAjaxResult(Localize("NoEnoughPoint", "积分不足")));
}
if (User.SaltAndHash(password, account.PasswordSalt) != account.Password)
{
return(new DataAjaxResult(Localize("error.Password", "密码错误")));
}
account.Point -= gift.Point;
TransactionHelper.BeginTransaction();
AccountService.Update(account);
DealLogService.Create(new DealLog(serialNo, DealTypes.Gift, 0, -gift.Point, null, null, account, null, gift.PointGiftId));
Logger.LogWithSerialNo(LogTypes.AccountDoGift, serialNo, account.AccountId, account.Name, gift.DisplayName);
return(TransactionHelper.CommitAndReturn(new DataAjaxResult()));
}
catch (System.Exception ex)
{
Logger.Error(LogTypes.AccountDoGift, ex);
return(new DataAjaxResult(Localize("Error", "兑换失败")));
}
}
public IMessageProvider Save()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var roleIds = Roles.GetCheckedIds();
InnerObject.BuildIn = false;
InnerObject.State = UserStates.Normal;
InnerObject.SetPassword(Password ?? "");
if (string.IsNullOrEmpty(Password))
{
InnerObject.SetPassword(Password);
}
MembershipService.CreateUser(InnerObject);
base.OnSaved(InnerObject);
MembershipService.AssignRoles(InnerObject, roleIds);
Logger.LogWithSerialNo(LogTypes.AdminUserCreate, serialNo, InnerObject.UserId, InnerObject.Name);
AddMessage("success", InnerObject.Name);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Create()
{
var serialNo = SerialNoHelper.Create();
var roles = MembershipService.QueryRoles(new RoleRequest {
Name = RoleNames.DistributorOwner
}).ToList();
TransactionHelper.BeginTransaction();
InnerObject.DistributorLevel = DistributorLevel;
OnSave(InnerObject, Owner);
var user = this.SecurityHelper.GetCurrentUser();
if (user is AdminUserModel)
{
InnerObject.ParentId = 0;
}
else if (user is DistributorUserModel)
{
InnerObject.ParentId = ((DistributorUserModel)user).DistributorId;
}
Owner.SetPassword(Password);
InnerObject.State = States.Normal;//经销商状态
Owner.State = States.Normal;
MembershipService.CreateUser(Owner);
InnerObject.UserId = Owner.UserId;
DistributorService.Create(InnerObject);
UpdateAccountLevelPolicy(InnerObject);
MembershipService.AssignRoles(Owner, roles.Select(x => x.RoleId).ToArray());
DistributorDealLog log = new DistributorDealLog(serialNo, DealTypes.Open, 0, null, null, null, InnerObject, 0);
//DistributorDealLogService.Create(log);
AddMessage("success", this.UserName);
Logger.LogWithSerialNo(LogTypes.DistributorCreate, serialNo, InnerObject.DistributorId, this.UserName);
CacheService.Refresh(CacheKeys.PosKey);
return(TransactionHelper.CommitAndReturn(this));
}
public IMessageProvider Save( )
{
Account account = null;
var currentUser = SecurityHelper.GetCurrentUser();
AccountUserModel accountUser = currentUser as AccountUserModel;
if (accountUser != null)
{
account = accountUser.Accounts.FirstOrDefault();
}
if (account == null || (account.State != AccountStates.Normal && account.State != AccountStates.Invalid))
{
AddError(LogTypes.AccountChangePassword, "accountNoExisting");
return(this);
}
account.SetPassword(Password);
TransactionHelper.BeginTransaction();
AccountService.Update(account);
Logger.LogWithSerialNo(LogTypes.AccountChangePassword, SerialNoHelper.Create(), account.AccountId, AccountName);
AddMessage("success");
return(TransactionHelper.CommitAndReturn(this));
}
public SimpleAjaxResult Create()
{
var serialNo = SerialNoHelper.Create();
var user = MembershipService.GetUserByName(this.UserName);
if (user == null)
{
return(new SimpleAjaxResult(Localize("nonFoundUser", UserName ?? "")));
}
TransactionHelper.BeginTransaction();
var guid = Guid.NewGuid().ToString("N").ToLower().Substring(0, 16);
var token = BitConverter.ToString(Encoding.ASCII.GetBytes(guid)).Replace("-", "");
user.LoginToken = token;
user.LoginInToken = IsActived;
MembershipService.UpdateUser(user);
Logger.LogWithSerialNo(LogTypes.CreateDog, serialNo, user.UserId, user.DisplayName);
return(TransactionHelper.CommitAndReturn(new DataAjaxResult()
{
Data1 = token
}));
}
public AccountServiceResponse Save()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var newAccount = AccountService.GetByName(AccountName);
if (newAccount == null || newAccount.State != AccountStates.Ready)
{
return(new AccountServiceResponse(ResponseCode.NonFoundAccount));
}
var oldAccount = AccountService.GetByName(OldAccountName);
if (oldAccount == null ||
(oldAccount.State != AccountStates.Normal && oldAccount.State != AccountStates.Invalid))
{
return(new AccountServiceResponse(ResponseCode.NonFoundAccount));
}
oldAccount.Remark1 = "Ô¿¨ºÅ£º" + newAccount.Name;
oldAccount.Name = newAccount.Name;
oldAccount.AccountToken = newAccount.AccountToken;
oldAccount.Password = newAccount.Password;
oldAccount.PasswordSalt = newAccount.PasswordSalt;
var owner = (AccountUser)(oldAccount.OwnerId.HasValue ? MembershipService.GetUserById(oldAccount.OwnerId.Value) : null);
Logger.LogWithSerialNo(LogTypes.AccountChangeName, serialNo, oldAccount.AccountId, OldAccountName, AccountName);
var fee = HostSite.ChangeCardFee;
if (fee.HasValue)
{
SystemDealLogService.Create(new SystemDealLog(serialNo, SecurityHelper.GetCurrentUser().CurrentUser)
{
Addin = oldAccount.AccountId.ToString(),
Amount = fee.Value,
DealType = SystemDealLogTypes.ChangeCard
});
oldAccount.ChargingAmount += fee.Value;
CashDealLogService.Create(new CashDealLog(fee.Value, 0, SecurityHelper.GetCurrentUser().CurrentUser.UserId, CashDealLogTypes.ChangeCard));
}
AccountService.Delete(newAccount);
AccountService.Update(oldAccount);
var response = new AccountServiceResponse(ResponseCode.Success, null, ShopService.GetById(oldAccount.ShopId), oldAccount, owner);
var accountType = AccountTypeService.GetById(oldAccount.AccountTypeId);
if (!string.IsNullOrWhiteSpace(HostSite.MessageTemplateOfAccountChangeName))
{
if (owner != null && owner.IsMobileAvailable)
{
var msg = MessageFormator.Format(HostSite.MessageTemplateOfAccountChangeName, owner);
SmsHelper.Send(owner.Mobile, msg);
}
}
if (!string.IsNullOrWhiteSpace(HostSite.TicketTemplateOfChangeAccountName))
{
var msg = MessageFormator.FormatTickForChangeAccountName(
HostSite.TicketTemplateOfChangeAccountName,
HostSite,
serialNo,
OldAccountName,
oldAccount,
owner,
accountType,
SecurityHelper.GetCurrentUser().CurrentUser);
PrintTicketService.Create(new PrintTicket(LogTypes.AccountChangeName, serialNo, msg, oldAccount));
response.CodeText = msg;
}
return(TransactionHelper.CommitAndReturn(response));
}
public SimpleAjaxResult Save()
{
try
{
var serialNo = SerialNoHelper.Create();
if (Amount < 0)
{
return(new SimpleAjaxResult(Localize("invalidAmount")));
}
TransactionHelper.BeginTransaction();
var account1 = AccountService.GetByName(AccountName);
if (account1 == null || (account1.State != AccountStates.Normal && account1.State != AccountStates.Invalid))
{
return(new SimpleAjaxResult(string.Format(Localize("accountNonFound"), AccountName)));
}
var account2 = AccountService.GetByName(AccountNameTo);
if (account2 == null || (account2.State != AccountStates.Normal && account2.State != AccountStates.Invalid))
{
return(new SimpleAjaxResult(string.Format(Localize("accountNonFound"), AccountNameTo)));
}
var accountType = AccountTypeService.GetById(account1.AccountTypeId);
if (accountType == null || !accountType.IsRecharging)
{
return(new SimpleAjaxResult(string.Format(Localize("accountCannotRecharging"), AccountName)));
}
accountType = AccountTypeService.GetById(account2.AccountTypeId);
if (accountType == null || !accountType.IsRecharging)
{
return(new SimpleAjaxResult(string.Format(Localize("accountCannotRecharging"), AccountNameTo)));
}
if (Amount == 0)
{
Amount = account1.Amount;
}
if (account1.Amount < Amount)
{
return(new SimpleAjaxResult(Localize("invalidAmount")));
}
var passSvc = UnityContainer.Resolve <IPasswordService>(HostSite.PasswordType);
var password = passSvc.Decrypto(Password);
if (User.SaltAndHash(password, account1.PasswordSalt) != account1.Password)
{
return(new SimpleAjaxResult(Localize("invalidPassword", "ÃÜÂë´íÎó")));
}
account1.Amount -= Amount;
account2.Amount += Amount;
AccountService.Update(account1);
AccountService.Update(account2);
// transfer in
DealLog dealLog = new DealLog(serialNo);
dealLog.Account = account1;
dealLog.Addin = account1.AccountId;
dealLog.Amount = Amount;
dealLog.DealType = DealTypes.TransferOut;
DealLogService.Create(dealLog);
// transfer out
dealLog = new DealLog(serialNo);
dealLog.Account = account2;
dealLog.Addin = account2.AccountId;
dealLog.Amount = -Amount;
dealLog.DealType = DealTypes.TransferIn;
DealLogService.Create(dealLog);
Logger.LogWithSerialNo(LogTypes.AccountTransfer, serialNo, account1.AccountId, account1.Name, account2.Name, Amount);
var r = new DataAjaxResult();
if (!string.IsNullOrWhiteSpace(HostSite.TicketTemplateOfTransfer))
{
r.Data1 = MessageFormator.FormatTickForTransfer(HostSite.TicketTemplateOfTransfer, serialNo,
account1,
account1.OwnerId.HasValue ? MembershipService.GetUserById(account1.OwnerId.Value) : null,
AccountTypeService.GetById(account1.AccountTypeId),
account2,
account2.OwnerId.HasValue ? MembershipService.GetUserById(account2.OwnerId.Value) : null,
AccountTypeService.GetById(account2.AccountTypeId),
SecurityHelper.GetCurrentUser().CurrentUser
);
PrintTicketService.Create(new PrintTicket(LogTypes.AccountTransfer, serialNo, r.Data1.ToString(), account1));
}
return(TransactionHelper.CommitAndReturn(r));
}
catch (System.Exception ex)
{
Logger.Error(LogTypes.AccountTransfer, ex);
return(new SimpleAjaxResult(Localize("SystemError")));
}
}
public AccountServiceResponse Save()
{
try
{
Account account = null;
var accountUser = (AccountUser)_membershipService.GetByMobile(AccountName.Trim());
if (accountUser != null)
{
account = AccountService.QueryByOwnerId(accountUser).FirstOrDefault();
//return new AccountServiceResponse(ResponseCode.NonFoundAccount) { CodeText = "找不到会员，请检查输入是否正确，会员卡状态是否正常！" };
}
else
{
account = AccountService.GetByName(AccountName.Trim());
}
this.AccountName = account.Name;
var serialNo = SerialNoHelper.Create();
//var site = SiteService.Query(null).FirstOrDefault();
User operatorUser = SecurityHelper.GetCurrentUser().CurrentUser;
RechargingCommand command = new RechargingCommand(serialNo, this.AccountName, this.Amount, this.HasReceipt, HowToDeal, operatorUser.UserId, null);
UnityContainer.BuildUp(command);
int code = command.Validate();
if (code != ResponseCode.Success)
{
return(new AccountServiceResponse(code));
}
//ApplyToModel apply = new ApplyToModel(command.DealWay.ApplyTo);
//if (!apply.EnabledRecharging)
// return new AccountServiceResponse(ResponseCode.InvalidateDealWay);
TransactionHelper.BeginTransaction();
Logger.LogWithSerialNo(LogTypes.AccountRecharge, serialNo, command.Account.AccountId, AccountName, Amount);
//if (command.DealWay.IsCash)
//{
// CashDealLogService.Create(new CashDealLog(Amount, 0, SecurityHelper.GetCurrentUser().CurrentUser.UserId, SystemDealLogTypes.Recharge));
// command.IsCash = true;
//}
//if (!HostSite.IsRechargingApprove)
command.Execute(operatorUser);
var response = new AccountServiceResponse(ResponseCode.Success, command.CreateDealLog(), ShopService.GetById(command.Account.ShopId), command.Account, command.Owner);
//else
// TaskService.Create(new Task(command, operatorUser.UserId) { AccountId = command.Account.AccountId, Amount = Amount });
var dealLog = command.CreateDealLog();
//if (!string.IsNullOrWhiteSpace(CurrentSite.TicketTemplateOfRecharge))
//{
// var message = MessageFormator.FormatTickForRecharging(CurrentSite.TicketTemplateOfRecharge,
// CurrentSite, this.HasReceipt, Amount,
// command.DealWay.DisplayName, dealLog, command.Account, command.AccountType,
// command.Owner, command.OperatorUser);
// PrintTicketService.Create(new PrintTicket(LogTypes.AccountRecharge, serialNo, message, command.Account));
// response.CodeText = message.FormatForJavascript();
//}
return(TransactionHelper.CommitAndReturn(response));
}
catch (Exception ex)
{
Logger.Error(LogTypes.AccountRecharge, ex);
throw;
}
}
public List <RechargingLog> AreaRecharges(out string pageHtml, out int tatolCount)
{
var user = SecurityHelper.GetCurrentUser();
pageHtml = string.Empty;
List <RechargingLog> listResp = new List <RechargingLog>();
tatolCount = 0;
if (user is AdminUserModel)
{
if (Amount > 0)
{
string Name = string.Empty;
List <Account> accountNames = new List <Account>();
for (int i = StartNum; i <= EndNum; i += 1)
{
Name = string.Format("{0:" + AccountName + "}", i);
var account = AccountService.GetAccountByName(Name);
if (account != null)
{
accountNames.Add(account);
}
}
try
{
if (accountNames != null && accountNames.Count > 0)
{
User operatorUser = SecurityHelper.GetCurrentUser().CurrentUser;
TransactionHelper.BeginTransaction();
// AccountServiceResponse response = null;
var serialNoAll = DateTime.Now.ToString("yyyyMMddHHmmss");
foreach (var item in accountNames)
{
RechargingLog log = new RechargingLog(1)
{
SubmitTime = DateTime.Now
};
var serialNo = SerialNoHelper.Create();
var oldAmount = item.Amount;
RechargingCommand command = new RechargingCommand(serialNo, item.Name, this.Amount, this.HasReceipt, HowToDeal, operatorUser.UserId, item);
UnityContainer.BuildUp(command);
int code = command.Validates();
if (code != ResponseCode.Success)
{
listResp.Add(new RechargingLog(code));
}
Logger.LogWithSerialNo(LogTypes.AccountRecharge, serialNo, command.Account.AccountId, item.Name, Amount);
command.Execute(operatorUser);
//response = new AccountServiceResponse(ResponseCode.Success) { AccountName = item.Name, Amount = item.Amount, DealAmount = Amount, DetainAmount = oldAmount, OwnerDisplayName = command.Owner == null ? "" : command.Owner.DisplayName };
log.AccountName = item.Name;
log.RechargAccountAmount = item.Amount;
log.Name = command.Owner == null ? "" : command.Owner.DisplayName;
log.serialNoAll = serialNoAll;
log.RechargingAmount = Amount;
log.AccountAmount = oldAmount;
listResp.Add(log);
RechargingLogService.Create(log);
var dealLog = command.CreateDealLog();
}
var list = listResp.Skip <RechargingLog>(0).Take <RechargingLog>(10).ToList <RechargingLog>();
tatolCount = listResp.Count;
pageHtml = MvcPage.AjaxPager(1, 10, tatolCount);
return(TransactionHelper.CommitAndReturn(list));
}
}
catch (Exception ex)
{
Logger.Error(LogTypes.AccountRecharge, ex);
listResp.Add(new RechargingLog(ResponseCode.SystemError));
}
}
else
{
listResp.Add(new RechargingLog(111));
}
}
else
{
listResp.Add(new RechargingLog(11112));
}
return(listResp);
}
public AccountServiceResponse Save()
{
var serialNo = SerialNoHelper.Create();
string password1 = "";
string password2 = "";
var passSvc = UnityContainer.Resolve <IPasswordService>(HostSite.PasswordType);
passSvc.Decrypto(Password, PasswordConfirm, out password1, out password2);
if (!string.IsNullOrEmpty(password1) || !string.IsNullOrEmpty(password2))
{
if (password1 != password2)
{
return(new OpenAccountServiceResponse(ResponseCode.SystemError)
{
CodeText = "两次密码输入不一致"
});
}
}
string accountName = AccountName.TrimSafty();
var operatorUser = SecurityHelper.GetCurrentUser().CurrentUser;
//try
//{
// if (CodeHelper.GetObject<string>("sms") != Code || CodeHelper.GetObject<string>("sms_mobile") != Mobile)
// {
// Mobile = "";
// }
//}
//catch
//{
//}
if (!string.IsNullOrWhiteSpace(Mobile))
{
User u = MembershipService.GetByMobile(Mobile);
if (u != null)
{
return(new AccountServiceResponse(-1)
{
CodeText = "手机号已绑定"
});
}
}
var command = new OpenAccountCommand(serialNo, accountName, password1, DisplayName, BirthDate, IsActived, HowToDeal, Identify, Remark1, operatorUser.UserId, SaleId, Gender, Mobile);
UnityContainer.BuildUp(command);
int code = command.Validate();
if (code != ResponseCode.Success)
{
return(new AccountServiceResponse(code));
}
TransactionHelper.BeginTransaction();
command.Execute(operatorUser);
decimal?saleFee = 0m;
if (command.AccountType != null)
{
saleFee = HostSite.SaleCardFee;
// 手续费
//
if (saleFee != null && saleFee.Value != 0m)
{
var account = AccountService.GetByName(accountName);
account.ChargingAmount += saleFee.Value;
AccountService.Update(account);
var d = DealWayService.Query().FirstOrDefault(x => x.State == DealWayStates.Normal);
var systemDealLog = new SystemDealLog(serialNo, operatorUser)
{
Amount = saleFee.Value, DealWayId = (d == null ? 0 : d.DealWayId), DealType = SystemDealLogTypes.SaldCardFee, Addin = account.AccountId.ToString()
};
SystemDealLogService.Create(systemDealLog);
if (d.IsCash)
{
CashDealLogService.Create(new CashDealLog(systemDealLog.Amount, 0, operatorUser.UserId, systemDealLog.DealType));
}
}
}
// sale Id
//
var accountShop = ShopService.GetById(command.Account.ShopId);
Logger.LogWithSerialNo(LogTypes.AccountOpen, serialNo, command.Account.AccountId, command.Account.Name);
var r = new OpenAccountServiceResponse(ResponseCode.Success, command.DealLog, accountShop, command.Account, command.Owner)
{
SaleFee = saleFee == null ? 0m : saleFee.Value,
DepositAmount = command.Account.DepositAmount
};
if (command.AccountType != null)
{
r.AccountType = command.AccountType.DisplayName;
}
if (!string.IsNullOrEmpty(this.HostSite.TicketTemplateOfOpen))
{
var dealLog = command.DealLog;
var msg = this.HostSite.TicketTemplateOfOpen;
msg = MessageFormator.FormatForOperator(msg, SecurityHelper.GetCurrentUser());
msg = MessageFormator.Format(msg, dealLog);
msg = MessageFormator.FormatHowToDeal(msg, command.DealWay.DisplayName);
msg = MessageFormator.Format(msg, command.DealLog);
msg = MessageFormator.Format(msg, command.AccountType);
msg = MessageFormator.Format(msg, command.Owner);
msg = MessageFormator.Format(msg, HostSite);
r.CodeText = msg;
PrintTicketService.Create(new PrintTicket(LogTypes.AccountOpen, serialNo, msg, command.Account));
}
return(TransactionHelper.CommitAndReturn(r));
}
public AccountServiceResponse Save()
{
var serialNo = SerialNoHelper.Create();
TransactionHelper.BeginTransaction();
var account = AccountService.GetByName(AccountName);
if (account == null)
{
return(new AccountServiceResponse(ResponseCode.NonFoundAccount));
}
if (account.State != AccountStates.Normal)
{
return(new AccountServiceResponse(ResponseCode.AccountStateInvalid));
}
AccountUser owner = null;
if (account.OwnerId.HasValue)
{
owner = MembershipService.GetUserById(account.OwnerId.Value) as AccountUser;
}
var accountType = AccountTypeService.GetById(account.AccountTypeId);
bool isRenew = false;
int renewalMonth = 6;
if (accountType != null)
{
isRenew = accountType.IsRenew;
renewalMonth = accountType.RenewMonths;
}
if (!isRenew)
{
return(new AccountServiceResponse(ResponseCode.NonRenewal));
}
var now = DateTime.Now;
account.ExpiredDate = (now > account.ExpiredDate ? now : account.ExpiredDate).AddMonths(renewalMonth);
AccountService.Update(account);
Logger.LogWithSerialNo(LogTypes.AccountRenew, serialNo, account.AccountId, AccountName, accountType.RenewMonths);
if (!string.IsNullOrWhiteSpace(HostSite.MessageTemplateOfAccountRenew))
{
if (owner != null && owner.IsMobileAvailable)
{
if (accountType.IsSmsRenew)
{
var msg = MessageFormator.Format(HostSite.MessageTemplateOfAccountRenew, owner);
msg = MessageFormator.Format(msg, account);
SmsHelper.Send(owner.Mobile, msg);
}
}
}
var response = new AccountServiceResponse(ResponseCode.Success, null, ShopService.GetById(account.ShopId), account, owner);
if (!string.IsNullOrWhiteSpace(HostSite.TicketTemplateOfRenewAccount))
{
var msg = MessageFormator.FormatTickForRenewAccount(HostSite.TicketTemplateOfRenewAccount, serialNo, HostSite, account, owner, accountType,
SecurityHelper.GetCurrentUser().CurrentUser);
response.CodeText = msg;
PrintTicketService.Create(new PrintTicket(LogTypes.AccountRenew, serialNo, msg, account));
}
return(TransactionHelper.CommitAndReturn(response));
}
