/// <summary>
/// 解除符合解除管制标准的用户（永久管制的用户不会自动解除管制）
/// </summary>
/// <param name="noModeratedUserPoint">用户自动接触管制状态所需的积分（用户综合积分）</param>
/// <returns>被解除管制的用户集合</returns>
public IEnumerable <User> NoModeratedUsers(int noModeratedUserPoint)
{
if (noModeratedUserPoint <= 0)
{
return(new List <User>());
}
PointSettings pointSettings = DIContainer.Resolve <ISettingsManager <PointSettings> >().Get();
Database dao = CreateDAO();
dao.OpenSharedConnection();
var sql_select = PetaPoco.Sql.Builder;
sql_select.Select("UserId")
.From("tn_Users")
.Where("IsForceModerated = @0 ", false)
.Where("IsModerated = @0", true);
sql_select.Where("ExperiencePoints * @0 + ReputationPoints * @1 > @2", pointSettings.ExperiencePointsCoefficient, pointSettings.ReputationPointsCoefficient, noModeratedUserPoint);
IEnumerable <object> userIds_object = dao.FetchFirstColumn(sql_select);
var sql_update = PetaPoco.Sql.Builder;
sql_update.Append("update tn_Users set IsModerated = @0 ", false)
.Where("IsForceModerated = @0 ", false)
.Where("IsModerated = @0", true)
.Where("ExperiencePoints * @0 + ReputationPoints * @1 > @2", pointSettings.ExperiencePointsCoefficient, pointSettings.ReputationPointsCoefficient, noModeratedUserPoint);
dao.Execute(sql_update);
dao.CloseSharedConnection();
return(PopulateEntitiesByEntityIds <long>(userIds_object.Cast <long>()));
}
private void RewardAndPunishmentUser_After(IUser sender, RewardAndPunishmentUserEventArgs eventArgs)
{
PointSettings pointSettings = pointSettingsManger.Get();
int totalPoints = pointSettings.CalculateIntegratedPoint(sender.ExperiencePoints, sender.ReputationPoints);
//更新用户等级
//if (eventArgs.ExperiencePoints <= 0 && eventArgs.ReputationPoints <= 0)
// return;
IUserService userService = DIContainer.Resolve <IUserService>();
UserRankService userRankService = new UserRankService();
SortedList <int, UserRank> userRanks = userRankService.GetAll();
UserRank maxUserRank = null;
if (userRanks != null && userRanks.Count > 0)
{
maxUserRank = userRanks.First().Value;
}
foreach (KeyValuePair <int, UserRank> userRank in userRanks)
{
if (totalPoints > userRank.Value.PointLower && userRank.Value.PointLower > maxUserRank.PointLower)
{
maxUserRank = userRank.Value;
}
}
userService.UpdateRank(sender.UserId, maxUserRank.Rank);
//自动解除管制
var user = userService.GetFullUser(sender.UserId);
if (user.IsModerated && !user.IsForceModerated)
{
UserSettings userSettings = userSettingsManager.Get();
if (totalPoints > userSettings.NoModeratedUserPoint)
{
userService.NoModeratedUser(user.UserId);
}
}
//发送通知
if (sender == null)
{
return;
}
Notice notice = Notice.New();
notice.UserId = sender.UserId;
notice.ApplicationId = 0;
notice.TypeId = NoticeTypeIds.Instance().Hint();
if (eventArgs.ExperiencePoints < 0 || eventArgs.ReputationPoints < 0 || eventArgs.TradePoints < 0)
{
notice.Body = "您被系统扣除经验:" + -eventArgs.ExperiencePoints + "、威望:" + -eventArgs.ReputationPoints + "、金币:" + -eventArgs.TradePoints;
}
else
{
notice.Body = "您收到系统奖励经验:" + eventArgs.ExperiencePoints + "、威望:" + eventArgs.ReputationPoints + "、金币:" + eventArgs.TradePoints;
}
notice.LeadingActorUrl = SiteUrls.FullUrl(SiteUrls.Instance().ListNotices(sender.UserName, null, null));
noticeService.Create(notice);
}
/*
* /// <summary>
* ///
* /// </summary>
* /// <param name="throwOverMaxValueError"></param>
* /// <param name="throwOverMinValueError"></param>
* /// <param name="userID"></param>
* /// <param name="points">正数加分 负数减分</param>
* /// <param name="userPoints"></param>
* /// <returns></returns>
* public static bool CheckPoints(bool throwOverMaxValueError, bool throwOverMinValueError, int userID, int[] points, out int[] userPoints)
* {
* return CheckPoints(throwOverMaxValueError, throwOverMinValueError, userID, points, true, out userPoints);
* }
* /// <summary>
* /// 检查积分 上下限
* /// </summary>
* /// <param name="userID"></param>
* /// <param name="points">要更新的积分值 8个</param>
* /// <param name="isAdd">如果为false 则points就是最终的积分 而不是增加或减少的积分 </param>
* /// <param name="resultPoints">如果检查成功 则返回用户更新后的积分</param>
* /// <returns></returns>
* public static bool CheckPoints(bool throwOverMaxValueError, bool throwOverMinValueError, int userID, int[] points, bool isAdd, out int[] userPoints)
* {
*
* User user = UserBO.Instance.GetUser(userID);
* userPoints = null;
* foreach (UserPoint userPoint in AllSettings.Current.PointSettings.UserPoints)
* {
* int pointID = (int)userPoint.Type;
*
* if (userPoint.Enable)
* {
* int resultPoint;
* if (isAdd)
* resultPoint = user.ExtendedPoints[pointID] + points[pointID];
* else
* resultPoint = points[pointID];
* if (points[pointID] > 0)
* {
*
* if (resultPoint > userPoint.MaxValue)
* {
* if (throwOverMaxValueError)
* {
* Context.ThrowError<UserPointOverMaxValueError>(new UserPointOverMaxValueError("UserPointOverMaxValueError", userPoint.Type, userPoint.MaxValue - user.ExtendedPoints[pointID], user.ExtendedPoints[pointID] + points[pointID], userPoint.MaxValue));
* return false;
* }
* if (isAdd)
* {
* if (user.ExtendedPoints[pointID] > userPoint.MaxValue)//原来已经大于上限 保留原值
* points[pointID] = user.ExtendedPoints[pointID];
* else
* points[pointID] = userPoint.MaxValue;
* }
* else
* points[pointID] = userPoint.MaxValue;
* }
* else
* points[pointID] = resultPoint;
* }
* else if (points[pointID] < 0)
* {
* if (resultPoint < userPoint.MinValue)
* {
* if (throwOverMinValueError)
* {
* Context.ThrowError<UserPointOverMinValueError>(new UserPointOverMinValueError("UserPointOverMinValueError", userPoint.Type, user.ExtendedPoints[pointID] - userPoint.MinValue, user.ExtendedPoints[pointID] + points[pointID], userPoint.MinValue));
* return false;
* }
* if (isAdd)
* {
* if (user.ExtendedPoints[pointID] < userPoint.MinValue)//原来已经小于下限 保留原值
* points[pointID] = user.ExtendedPoints[pointID];
* else
* points[pointID] = userPoint.MinValue;
* }
* else
* points[pointID] = userPoint.MinValue;
* }
* else
* points[pointID] = resultPoint;
* }
* else
* {
* if(isAdd)
* points[pointID] = user.ExtendedPoints[pointID];
* }
* }
* else
* {
* if (isAdd)
* points[pointID] = user.ExtendedPoints[pointID];
* }
* }
* userPoints = points;
*
* return true;
* }
*/
#region 积分相关设置
public static bool AddPointExchangeRule(UserPointType pointType, UserPointType targetPointType)
{
PointExchangeRule rule = new PointExchangeRule();
rule.PointType = pointType;
rule.TargetPointType = targetPointType;
if (pointType == targetPointType)
{
Context.ThrowError <UserPointCannotExchangeError>(new UserPointCannotExchangeError("UserPointCannotExchangeError", rule.UserPoint.Name, rule.TargetUserPoint.Name));
return(false);
}
if (rule.UserPoint.Enable == false)
{
Context.ThrowError <UserPointExchangeUnenabledPointError>(new UserPointExchangeUnenabledPointError("UserPointExchangeUnenabledPointError", rule.UserPoint.Name, rule.TargetUserPoint.Name, rule.UserPoint.Name));
return(false);
}
if (rule.TargetUserPoint.Enable == false)
{
Context.ThrowError <UserPointExchangeUnenabledPointError>(new UserPointExchangeUnenabledPointError("UserPointExchangeUnenabledPointError", rule.UserPoint.Name, rule.TargetUserPoint.Name, rule.TargetUserPoint.Name));
return(false);
}
PointExchangeRuleCollection rules = AllSettings.Current.PointSettings.PointExchangeRules;
PointExchangeRuleCollection tempRules = new PointExchangeRuleCollection();
foreach (PointExchangeRule tempRule in rules)
{
if (rule.Key == tempRule.Key)
{
Context.ThrowError <UserPointIsExistsExchangeRuleError>(new UserPointIsExistsExchangeRuleError("UserPointIsExistsExchangeRuleError", rule.UserPoint.Name, rule.TargetUserPoint.Name));
return(false);
}
tempRules.Add(tempRule);
}
tempRules.Add(rule);
if (HasUnCatchedError)
{
return(false);
}
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
setting.PointExchangeRules = tempRules;
if (!SettingManager.SaveSettings(setting))
{
return(false);
}
//AllSettings.Current.PointSettings = setting;
return(true);
}
/// <summary>
/// 根据一定规则重置所有的用户等级
/// </summary>
public void ResetAllUser()
{
PointSettings pointSettings = pointSettingsManager.Get();
var sql_Update = PetaPoco.Sql.Builder;
sql_Update.Append("update tn_Users set Rank = (select max(Rank) from tn_UserRanks UR where UR.PointLower <= (ExperiencePoints * @0 + ReputationPoints * @1) or ((ExperiencePoints * @0 + ReputationPoints * @1)<0 and UR.Rank = 1) )", pointSettings.ExperiencePointsCoefficient, pointSettings.ReputationPointsCoefficient);
CreateDAO().Execute(sql_Update);
}
public void DefaultTagsOverrideNull()
{
var point = PointData.Measurement("h2o")
.Tag("location", "europe")
.Tag("expensive", null)
.Field("level", 2);
var defaults = new PointSettings().AddDefaultTag("expensive", "true");
Assert.AreEqual("h2o,expensive=true,location=europe level=2i", point.ToLineProtocol(defaults));
}
public ActionResult _PointMenus(string spaceKey)
{
PointSettings pointSettings = pointSettingsManger.Get();
IUser user = userService.GetUser(spaceKey);
IEnumerable <PointCategory> pointCategories = pointService.GetPointCategories();
ViewData["totalPoints"] = pointSettings.CalculateIntegratedPoint(user.ExperiencePoints, user.ReputationPoints);
ViewData["traPoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("TradePoints"));
ViewData["expPoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("ExperiencePoints"));
ViewData["prePoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("ReputationPoints"));
return(View("_PointMenus", user));
}
public void DefaultTagsNotOverride()
{
var point = PointData.Measurement("h2o")
.Tag("location", "europe")
.Tag("expensive", "false")
.Field("level", 2);
var defaults = new PointSettings().AddDefaultTag("expensive", "true");
string lineProtocol = point.ToLineProtocol(defaults);
Assert.AreEqual("h2o,expensive=false,location=europe level=2i", lineProtocol);
}
public void DefaultTagsSorted()
{
var point = PointData.Measurement("h2o")
.Tag("location", "europe")
.Field("level", 2);
var defaults = new PointSettings()
.AddDefaultTag("a-expensive", "true")
.AddDefaultTag("z-expensive", "false");
Assert.AreEqual("h2o,a-expensive=true,location=europe,z-expensive=false level=2i",
point.ToLineProtocol(defaults));
}
/// <summary>
/// 更改用户积分
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
void ChangePointsEventModule_After(IUser sender, ChangePointsEventArgs eventArgs)
{
if (eventArgs.ExperiencePoints <= 0 && eventArgs.ReputationPoints <= 0)
{
return;
}
IUserService userService = DIContainer.Resolve <IUserService>();
//自动升级
UserRankService userRankService = new UserRankService();
SortedList <int, UserRank> userRanks = userRankService.GetAll();
UserRank maxUserRank = null;
if (userRanks != null && userRanks.Count > 0)
{
maxUserRank = userRanks.ElementAt(0).Value;
}
IPointSettingsManager pointSettingsManger = DIContainer.Resolve <IPointSettingsManager>();
PointSettings pointSettings = pointSettingsManger.Get();
int totalPoints = pointSettings.CalculateIntegratedPoint(sender.ExperiencePoints, sender.ReputationPoints);
foreach (KeyValuePair <int, UserRank> userRank in userRanks)
{
if (totalPoints > userRank.Value.PointLower && userRank.Value.PointLower > maxUserRank.PointLower)
{
maxUserRank = userRank.Value;
}
}
if (maxUserRank.Rank > sender.Rank)
{
userService.UpdateRank(sender.UserId, maxUserRank.Rank);
}
//自动解除管制
var user = userService.GetFullUser(sender.UserId);
if (user.IsModerated && !user.IsForceModerated)
{
UserSettings userSettings = DIContainer.Resolve <IUserSettingsManager>().Get();
if (totalPoints > userSettings.NoModeratedUserPoint)
{
userService.NoModeratedUser(user.UserId);
}
}
}
public ActionResult _ListPointItems(string spaceKey)
{
PointSettings pointSettings = pointSettingsManger.Get();
IEnumerable <PointItem> pointItems = pointService.GetPointItemsOfIncome();
IEnumerable <PointCategory> pointCategories = pointService.GetPointCategories();
ViewData["traPoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("TradePoints")).CategoryName;
ViewData["expPoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("ExperiencePoints")).CategoryName;
ViewData["prePoint"] = pointCategories.FirstOrDefault(n => n.CategoryKey.Equals("ReputationPoints")).CategoryName;
ViewData["pointCategories"] = pointCategories;
ViewData["pointRule"] = pointSettings.UserIntegratedPointRuleText;
return(View("_ListPointItems", pointItems));
}
private void Enable()
{
MessageDisplay msgDisplay = CreateMessageDisplay();
bool enable = _Request.IsChecked("enable", Method.Post, false);
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(PointSettings);
setting.EnablePointExchange = enable;
try
{
SettingManager.SaveSettings(setting);
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
private InfluxDBClientOptions(Builder builder)
{
Arguments.CheckNotNull(builder, nameof(builder));
Url = builder.UrlString;
LogLevel = builder.LogLevelValue;
AuthScheme = builder.AuthScheme;
Token = builder.Token;
Username = builder.Username;
Password = builder.Password;
Org = builder.OrgString;
Bucket = builder.BucketString;
Timeout = builder.Timeout;
ReadWriteTimeout = builder.ReadWriteTimeout;
PointSettings = builder.PointSettings;
}
private void DeleteExchangeRule()
{
MessageDisplay msgDisplay = CreateMessageDisplay();
string key = _Request.Get("key", Method.Get, string.Empty);
if (key == string.Empty)
{
msgDisplay.AddError(string.Format(Lang_Error.Global_InvalidParamError, "key"));
return;
}
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
PointExchangeRule rule = setting.PointExchangeRules.GetRule(key);
if (rule == null)
{
return;
}
setting.PointExchangeRules.Remove(rule);
try
{
if (!SettingManager.SaveSettings(setting))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error.TatgetName, error.TargetLine, error.Message);
});
}
else
{
AllSettings.Current.PointSettings = setting;
}
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
/// <summary>
/// 删除等级图标设置
/// </summary>
/// <param name="pointType"></param>
/// <returns></returns>
public static bool DeletePointIcon(UserPointType pointType)
{
lock (AllSettings.Current.PointSettings)
{
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
for (int i = 0; i < setting.PointIcons.Count; i++)
{
if (setting.PointIcons[i].PointType == pointType)
{
setting.PointIcons.RemoveAt(i);
break;
}
}
bool success = SettingManager.SaveSettings(setting);
//if (success)
// AllSettings.Current.PointSettings = setting;
return(success);
}
}
private void SavepointExchangeProportions()
{
UserPointCollection userPoints = AllSettings.Current.PointSettings.EnabledUserPoints;
string[] errorNames = new string[userPoints.Count];
int i = 0;
foreach (UserPoint userPoint in userPoints)
{
errorNames[i] = userPoint.Type.ToString();
i++;
}
MessageDisplay msgDisplay = CreateMessageDisplay(errorNames);
PointExchangeProportionCollection pointExchangeProportions = new PointExchangeProportionCollection();
foreach (UserPoint userPoint in AllSettings.Current.PointSettings.EnabledUserPoints)
{
string valueString = _Request.Get("pointExchangeProportion." + (int)userPoint.Type, Method.Post, string.Empty);
int value;
if (!int.TryParse(valueString, out value))
{
msgDisplay.AddError(userPoint.Type.ToString(), 0, string.Format(Lang_Error.User_UserPointExchangeFormatError, userPoint.Name));
}
else if (value < 1)
{
msgDisplay.AddError(userPoint.Type.ToString(), 0, string.Format(Lang_Error.User_UserPointExchangeFormatError, userPoint.Name));
}
else
{
pointExchangeProportions.Add(userPoint.Type, value);
}
}
if (msgDisplay.HasAnyError())
{
return;
}
//PointExchangeProportionCollection tempPointExchangeProportions = AllSettings.Current.UserPointSettings.ExchangeProportions;
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
setting.ExchangeProportions = pointExchangeProportions;
try
{
if (!SettingManager.SaveSettings(setting))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error);
});
}
else
{
AllSettings.Current.PointSettings = setting;
}
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
private void SavePointExchangeRules()
{
MessageDisplay msgDisplay = CreateMessageDisplay("taxRate", "minRemaining");
int[] ids = StringUtil.Split <int>(_Request.Get("ids", Method.Post, string.Empty));
PointExchangeRuleCollection rules = AllSettings.Current.PointSettings.PointExchangeRules;
int i = 0;
PointExchangeRuleCollection tempRules = new PointExchangeRuleCollection();
foreach (int id in ids)
{
string key = _Request.Get("key." + id, Method.Post, string.Empty);
PointExchangeRule rule = (PointExchangeRule)rules.GetRule(key).Clone();
if (rule == null)
{
continue;
}
string valueString = _Request.Get("taxRate." + id, Method.Post, string.Empty);
int value;
if (!int.TryParse(valueString, out value))
{
msgDisplay.AddError("taxRate", i, Lang_Error.User_UserPointExchangeTaxRateFormatError);
}
else
{
rule.TaxRate = value;
}
valueString = _Request.Get("minRemaining." + id, Method.Post, string.Empty);
if (!int.TryParse(valueString, out value))
{
msgDisplay.AddError("minRemaining", i, Lang_Error.User_UserPointExchangeRemainingValueFormatError);
}
else if (value < rule.UserPoint.MinValue)
{
msgDisplay.AddError("minRemaining", i, Lang_Error.User_UserPointInvalidTradeMaxValueError);
rule.MinRemainingValue = value;
}
else
{
rule.MinRemainingValue = value;
}
tempRules.Add(rule);
i++;
}
if (msgDisplay.HasAnyError())
{
return;
}
try
{
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
setting.PointExchangeRules = tempRules;
if (!SettingManager.SaveSettings(setting))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error.TatgetName, error.TargetLine, error.Message);
});
}
else
{
AllSettings.Current.PointSettings = setting;
}
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
/// <summary>
/// 如果用户的积分超出积分的上限或者下限则将其更新到上限或者下限
/// </summary>
/// <summary>
/// 更新扩展积分设置
/// </summary>
/// <param name="userPoints"></param>
/// <returns></returns>
public static bool UpdateUserPointSetting(UserPointCollection userPoints)
{
int enableCount = 0;
int i = 0;
string temp = AllSettings.Current.PointSettings.GeneralPointExpression.Replace("(", "").Replace(")", "").Replace("+", "|").Replace("-", "|").Replace("*", "|").Replace("/", "|").Replace(" ", "");
string[] colums = temp.Split('|');
StringBuilder cannotDisablePoints = new StringBuilder();
foreach (UserPoint userPoint in userPoints)
{
if (userPoint.Enable)
{
enableCount++;
if (string.IsNullOrEmpty(userPoint.Name))
{
Context.ThrowError <EmptyUserPointNameError>(new EmptyUserPointNameError("name", i));
}
if (userPoint.MaxValue <= userPoint.MinValue)
{
Context.ThrowError <InvalidUserPointMaxValueAndMinValueError>(new InvalidUserPointMaxValueAndMinValueError("maxValue", i));
}
if (userPoint.InitialValue > userPoint.MaxValue)
{
Context.ThrowError <UserPointInitialValueGreaterthanMaxValueError>(new UserPointInitialValueGreaterthanMaxValueError("initialValue", i));
}
else if (userPoint.InitialValue < userPoint.MinValue)
{
Context.ThrowError <UserPointInitialValueLessthanMinValueError>(new UserPointInitialValueLessthanMinValueError("initialValue", i));
}
}
else
{
foreach (string colum in colums)
{
if (string.Compare(colum, "p" + ((int)userPoint.Type + 1), true) == 0)
{
cannotDisablePoints.Append("\"").Append(userPoint.Name).Append("\",");
break;
}
}
}
i++;
}
if (cannotDisablePoints.Length > 0)
{
Context.ThrowError <UserPointCanNotDisablePointsError>(new UserPointCanNotDisablePointsError(cannotDisablePoints.ToString(0, cannotDisablePoints.Length - 1)));
return(false);
}
if (enableCount == 0)
{
Context.ThrowError <NoEnableUserPointError>(new NoEnableUserPointError("NoEnableUserPointError"));
return(false);
}
if (HasUnCatchedError)
{
return(false);
}
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
setting.UserPoints = userPoints;
if (SettingManager.SaveSettings(setting))
{
AllSettings.Current.PointSettings = setting;
return(true);
}
return(false);
}
/// <summary>
/// 积分交易
/// </summary>
/// <param name="payerUserId">支付积分人UserId</param>
/// <param name="payeeUserId">接收积分人UserId</param>
/// <param name="points">交易积分额</param>
/// <param name="description">交易描述</param>
/// <param name="isImmediate">是否即时交易</param>
/// <param name="needPointMessage">是否需要积分提醒</param>
public void Trade(long payerUserId, long payeeUserId, int points, string description, bool isImmediate)
{
//如果是即时交易，从支付方从交易积分扣除，否则从冻结的交易积分扣除（不足时抛出异常）
if (points <= 0)
{
return;
}
//1、首先检查payerUserId是否可以支付积分交易额，如果余额不足抛出异常
IUserService userService = DIContainer.Resolve <IUserService>();
IUser payer = userService.GetUser(payerUserId);
if (payer == null)
{
throw new ExceptionFacade(string.Format("用户“{0}”不存在或已被删除", payerUserId));
}
PointCategory pointCategory = GetPointCategory(PointCategoryKeys.Instance().TradePoints());
if (pointCategory == null)
{
return;
}
if (isImmediate && payer.TradePoints < points)
{
throw new ExceptionFacade(string.Format("积分余额不足，仅有{0}{2}{3}，不够支付{1}{2}{3}", payer.TradePoints, points, pointCategory.Unit, pointCategory.CategoryName));
}
if (!isImmediate && payer.FrozenTradePoints < points)
{
throw new ExceptionFacade(string.Format("冻结积分余额不足，仅有{0}{2}{3}，不够支付{1}{2}{3}", payer.FrozenTradePoints, points, pointCategory.Unit, pointCategory.CategoryName));
}
IUser payee = userService.GetUser(payeeUserId);
if (payee == null)
{
throw new ExceptionFacade(string.Format("用户“{0}”不存在或已被删除", payeeUserId));
}
//2、检查是否需要缴纳交易税，如果需要，则创建系统积分记录，变更系统积分总额
PointSettings pointSettings = pointSettingsManager.Get();
int realPoints = points;
if (pointSettings.TransactionTax > 0 && pointSettings.TransactionTax < 100)
{
realPoints = points * (100 - pointSettings.TransactionTax) / 100;
int taxPoints = points - realPoints;
if (taxPoints > 0)
{
PointRecord pointRecord = new PointRecord(0, ResourceAccessor.GetString("Common_TransactionTax"), description, 0, 0, taxPoints);
pointRecordRepository.Insert(pointRecord);
ChangeSystemTradePoints(taxPoints);
}
}
//3、points去除交易税，分别变更交易双方的积分值，并生成积分记录
PointRecord payerPointRecord = new PointRecord(payerUserId, ResourceAccessor.GetString("Common_PointTrade"), description, 0, 0, -points);
pointRecordRepository.Insert(payerPointRecord);
if (isImmediate)
{
userService.ChangePoints(payerUserId, 0, 0, -points);
}
else
{
userService.ReduceFrozenTradePoints(payerUserId, points);
}
//用于积分提醒
TrackPointRecord(payerUserId, payerPointRecord);
PointRecord payeePointRecord = new PointRecord(payeeUserId, ResourceAccessor.GetString("Common_PointTrade"), description, 0, 0, realPoints);
pointRecordRepository.Insert(payeePointRecord);
userService.ChangePoints(payeeUserId, 0, 0, realPoints);
}
/// <summary>
/// 更新积分等级图标
/// </summary>
/// <param name="pointType"></param>
/// <param name="pointValue">初级图标 所需积分</param>
/// <param name="iconCount"> 升上一级图标 所需当前图标个数</param>
/// <param name="icons"></param>
/// <returns></returns>
public static bool UpdatePointIcon(UserPointType pointType, int pointValue, int iconCount, IEnumerable <string> icons)
{
if (pointValue < 1)
{
Context.ThrowError <UserPointIconValueError>(new UserPointIconValueError("pointValue", AllSettings.Current.PointSettings.GetUserPoint(pointType).Name));
}
if (iconCount < 1)
{
Context.ThrowError <UserPointUpgradeIconCountError>(new UserPointUpgradeIconCountError("iconCount"));
}
List <string> tempIcons = new List <string>();
foreach (string icon in icons)
{
string tempIcon = icon.Trim();
if (tempIcons.Contains(icon))
{
Context.ThrowError <UserPointIconIsExistsError>(new UserPointIconIsExistsError("icons"));
return(false);
}
if (tempIcon != string.Empty && !tempIcons.Contains(icon))
{
tempIcons.Add(icon);
}
}
if (tempIcons.Count == 0)
{
Context.ThrowError <UserPointIconEmptyError>(new UserPointIconEmptyError("icons"));
}
if (HasUnCatchedError)
{
return(false);
}
string iconsString = StringUtil.Join(tempIcons, "|");
PointIcon pointIcon = new PointIcon();
pointIcon.PointType = pointType;
pointIcon.PointValue = pointValue;
pointIcon.IconCount = iconCount;
pointIcon.IconsString = iconsString;
lock (AllSettings.Current.PointSettings)
{
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
bool hasAdd = false;
for (int i = 0; i < setting.PointIcons.Count; i++)
{
if (setting.PointIcons[i].PointType == pointType)
{
setting.PointIcons[i] = pointIcon;
hasAdd = true;
}
}
if (!hasAdd)
{
setting.PointIcons.Add(pointIcon);
}
bool success = SettingManager.SaveSettings(setting);
//if (success)
// AllSettings.Current.PointSettings = setting;
return(success);
}
}
private void Save()
{
MessageDisplay msgDisplay = CreateMessageDisplay("money", "point", "minvalue");
PointRechargeRuleCollection rules = new PointRechargeRuleCollection();
int i = 0;
foreach (UserPoint point in AllSettings.Current.PointSettings.EnabledUserPoints)
{
int pointID = (int)point.Type;
PointRechargeRule rule = new PointRechargeRule();
rule.UserPointType = point.Type;
rule.Enable = _Request.IsChecked("canRecharge." + pointID, Method.Post, false);
rule.Money = _Request.Get <int>("money." + pointID, Method.Post, 0);
rule.Point = _Request.Get <int>("point." + pointID, Method.Post, 0);
rule.MinValue = _Request.Get <int>("minvalue." + pointID, Method.Post, 0);
if (rule.Enable)
{
if (rule.Money < 1)
{
msgDisplay.AddError("money", i, "人民币必须为大于0的整数");
}
if (rule.Point < 1)
{
msgDisplay.AddError("point", i, "积分数量必须为大于0的整数");
}
if (rule.Point < 1)
{
msgDisplay.AddError("minvalue", i, "一次至少需要充值的积分数量必须大于0");
}
}
rules.Add(rule);
i++;
}
if (msgDisplay.HasAnyError())
{
return;
}
PointSettings pointSetting = SettingManager.CloneSetttings <PointSettings>(PointSettings);
PaySettings paySettings = SettingManager.CloneSetttings <PaySettings>(PaySettings);
pointSetting.PointRechargeRules = rules;
paySettings.EnablePointRecharge = _Request.Get <bool>("enable", Method.Post, false);
if (paySettings.EnablePointRecharge)
{
paySettings.ProductName = _Request.Get("ProductName", Method.Post, string.Empty);
paySettings.EnableAlipay = _Request.Get <bool>("enableAlipay", Method.Post, false);
paySettings.EnableTenpay = _Request.Get <bool>("EnableTenpay", Method.Post, false);
paySettings.Enable99Bill = _Request.Get <bool>("Enable99Bill", Method.Post, false);
if (paySettings.EnableAlipay)
{
paySettings.Alipay_SellerEmail = _Request.Get("Alipay_SellerEmail", Method.Post, string.Empty);
paySettings.Alipay_PartnerID = _Request.Get("Alipay_PartnerID", Method.Post, string.Empty);
paySettings.Alipay_Key = _Request.Get("Alipay_Key", Method.Post, string.Empty);
}
if (paySettings.EnableTenpay)
{
paySettings.Tenpay_BargainorID = _Request.Get("Tenpay_BargainorID", Method.Post, string.Empty);
paySettings.Tenpay_Key = _Request.Get("Tenpay_Key", Method.Post, string.Empty);
}
if (paySettings.Enable99Bill)
{
paySettings._99Bill_MerchantAcctID = _Request.Get("_99Bill_MerchantAcctID", Method.Post, string.Empty);
paySettings._99Bill_Key = _Request.Get("_99Bill_Key", Method.Post, string.Empty);
}
}
else
{
paySettings.EnableAlipay = false;
paySettings.EnableTenpay = false;
paySettings.Enable99Bill = false;
}
if (paySettings.EnablePointRecharge)
{
foreach (PointRechargeRule rule in rules)
{
if (rule.Enable)
{
pointSetting.UserPoints.GetUserPoint(rule.UserPointType).MaxValue = int.MaxValue;
}
}
}
try
{
SettingManager.SaveSettings(pointSetting);
SettingManager.SaveSettings(paySettings);
PostBOV5.Instance.ClearShowChargePointLinks();
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
/// <summary>
/// 保存积分设置
/// </summary>
/// <returns></returns>
public void Save(PointSettings pointSettings)
{
repository.Save(pointSettings);
}
private void SavepointTransferRules()
{
string[] names = new string[] { "taxRate", "minRemaining" };
MessageDisplay msgDisplay = CreateMessageDisplay(names);
PointTransferRuleCollection rules = new PointTransferRuleCollection();
int i = 0;
foreach (UserPoint userPoint in AllSettings.Current.PointSettings.EnabledUserPoints)
{
int pointID = (int)userPoint.Type;
bool canTransfer = _Request.Get <bool>("canTransfer." + pointID, Method.Post, false);
string valueString = _Request.Get("taxRate." + pointID, Method.Post, string.Empty);
int taxRate = 0;
if (!int.TryParse(valueString, out taxRate))
{
msgDisplay.AddError("taxRate", i, Lang_Error.User_UserPointTransferTaxRateFormatError);
}
else if (taxRate < 0)
{
msgDisplay.AddError("taxRate", i, Lang_Error.User_UserPointTransferTaxRateFormatError);
}
valueString = _Request.Get("minRemaining." + pointID, Method.Post, string.Empty);
int minRemainingValue = 0;
if (!int.TryParse(valueString, out minRemainingValue))
{
msgDisplay.AddError("minRemaining", i, Lang_Error.User_UserPointTransferMinRemainingValueFormatError);
}
PointTransferRule rule = new PointTransferRule();
rule.CanTransfer = canTransfer;
rule.MinRemainingValue = minRemainingValue;
rule.PointType = userPoint.Type;
rule.TaxRate = taxRate;
rules.Add(rule);
}
if (msgDisplay.HasAnyError())
{
return;
}
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
try
{
setting.PointTransferRules = rules;
setting.EnablePointTransfer = _Request.IsChecked("enable", Method.Post, false);
if (!SettingManager.SaveSettings(setting))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error.TatgetName, error.TargetLine, error.Message);
});
}
else
{
AllSettings.Current.PointSettings = setting;
}
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
public void SetUp()
{
_pointSettings = new PointSettings();
}
private void SavePointOtherSetting()
{
MessageDisplay msgDisplay = CreateMessageDisplay("generalPointName", "generalPointExpression", "pointTradeRate");
string generalPointName = _Request.Get("generalPointName", Method.Post, string.Empty);
string generalPointExpression = _Request.Get("generalPointExpression", Method.Post, string.Empty);
string pointTradeRateString = _Request.Get("pointTradeRate", Method.Post, string.Empty);
if (generalPointName == string.Empty)
{
msgDisplay.AddError("generalPointName", Lang_Error.User_UserPointEmptyGeneralPointNameError);
}
int pointTradeRate;
if (!int.TryParse(pointTradeRateString, out pointTradeRate))
{
msgDisplay.AddError("pointTradeRate", Lang_Error.User_UserPointTradeRateFormatError);
}
bool displayGeneralPoint = _Request.Get <bool>("displayGeneralPoint", Method.Post, true);
if (msgDisplay.HasAnyError())
{
return;
}
try
{
if (!UserBO.Instance.UpdatePointsExpression(generalPointExpression))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error);
});
}
else
{
PointSettings setting = SettingManager.CloneSetttings <PointSettings>(AllSettings.Current.PointSettings);
string oldExpression = setting.GeneralPointExpression;
setting.GeneralPointName = generalPointName;
setting.GeneralPointExpression = generalPointExpression;
setting.TradeRate = pointTradeRate;
setting.DisplayGeneralPoint = displayGeneralPoint;
if (!SettingManager.SaveSettings(setting))
{
CatchError <ErrorInfo>(delegate(ErrorInfo error)
{
msgDisplay.AddError(error);
});
}
else
{
if (oldExpression != AllSettings.Current.PointSettings.GeneralPointExpression)
{
if (TaskManager.BeginTask(MyUserID, new ReCountUsersPointTask(), string.Empty))
{
}
}
}
//else
// AllSettings.Current.PointSettings = setting;
}
}
catch (Exception ex)
{
msgDisplay.AddError(ex.Message);
}
}
/// <summary> /// 升级程序使用的 /// </summary> /// <param name="pointSetting"></param> /// <returns></returns> public abstract PointExpressionColumCollection GetGeneralPointExpressionColums(PointSettings pointSetting);
public ActionResult AdressEditor(PointSettings pointSettings)
{
return(PartialView(pointSettings));
}
public ActionResult MyRank(string spaceKey)
{
IUser user = userService.GetUser(spaceKey);
PointSettings pointSettings = pointSettingsManger.Get();
pageResourceManager.InsertTitlePart("我的等级");
int totalPoints = pointSettings.CalculateIntegratedPoint(user.ExperiencePoints, user.ReputationPoints);
SortedList <int, UserRank> userRanks = userRankService.GetAll();
UserRank userRank = userRankService.Get(user.Rank);
if (userRank != null)
{
ViewData["userRankName"] = userRank.RankName;
}
ViewData["userRanks"] = userRanks;
ViewData["totalPoints"] = totalPoints;
if (user.Rank + 1 <= userRankService.GetAll().Count())
{
ViewData["nextRankName"] = userRankService.Get(user.Rank + 1).RankName;
ViewData["leftUpgradeExperiencePoints"] = userRankService.Get(user.Rank + 1).PointLower - totalPoints;
}
else
{
ViewData["leftUpgradeExperiencePoints"] = 0;
}
#region 计算进度条百分比
List <UserRank> ranks = userRanks.Values.ToList();
int a = (userRanks.Count() - 2) / 3;
int rank = user.Rank;
double leftPoints = 0;
if (rank >= 1 && rank < ranks.ElementAt(a).Rank)
{
leftPoints = totalPoints / (double)ranks.ElementAt(a).PointLower / 5;
}
else if (rank >= ranks.ElementAt(a).Rank&& rank < ranks.ElementAt(2 * a).Rank)
{
leftPoints = (totalPoints - ranks.ElementAt(a).PointLower) / (double)(ranks.ElementAt(2 * a).PointLower - ranks.ElementAt(a).PointLower) / 5 + 0.2;
}
else if (rank >= ranks.ElementAt(2 * a).Rank&& rank < ranks.ElementAt(3 * a).Rank)
{
leftPoints = (totalPoints - ranks.ElementAt(2 * a).PointLower) / (double)(ranks.ElementAt(3 * a).PointLower - ranks.ElementAt(2 * a).PointLower) / 5 + 0.4;
}
else if (rank >= ranks.ElementAt(3 * a).Rank&& rank < userRanks.ToArray()[userRanks.Count() - 1].Value.Rank)
{
leftPoints = (totalPoints - ranks.ElementAt(3 * a).PointLower) / (double)(userRanks.ToArray()[userRanks.Count() - 1].Value.PointLower - ranks.ElementAt(3 * a).PointLower) / 5 + 0.6;
}
else
{
leftPoints = totalPoints / double.MaxValue + 0.8;
}
ViewData["leftPoints"] = leftPoints;
#endregion
return(View(user));
}
