public static void ChangeINCalculatePointModel(CalculatePointModel thisCalResult)
{
thisCalResult.OldPoints = thisCalResult.NewPoints;
thisCalResult.NewAmounts = 0;
thisCalResult.NewPoints = 0;
thisCalResult.ProducePoints = 0;
thisCalResult.ProduceAmounts = 0;
}
public static CalculatePointModel INEqMD(PointRuler ruler, CalculatePointModel calData)
{
if (ruler.Point == 0)
{
INPoint0(ruler.Amount, ruler.Multiple, calData);
}
else
{
INPointNo0(ruler.PlusOrMinus, ruler.Point, ruler.Amount, ruler.Multiple, calData);
}
return(calData);
}
public static CalculatePointModel OUTEqYear(PointRuler ruler, CalculatePointModel calData)
{
if (ruler.Point == 0)
{
OUTAmount0(ruler.PlusOrMinus, ruler.Amount, ruler.Multiple, calData);
}
else
{
OUTAmountNo0(ruler.Deduction, ruler.PlusOrMinus, ruler.Point, ruler.Amount, ruler.Multiple, calData);
}
return(calData);
}
private static CalculatePointModel INPoint0(Int64 amount, Int64 multiple, CalculatePointModel calData)
{
if (amount == 0 && multiple != 0)
{
//翻倍沿用之前运算符号
calData.NewAmounts = calData.OldAmounts;
calData.NewPoints = calData.OldPoints * multiple;
calData.ProducePoints = calData.NewPoints - calData.OldPoints;
calData.ProduceAmounts = 0;
return(calData);
}
calData.NewAmounts = calData.OldAmounts;
calData.NewPoints = calData.OldPoints;
calData.ProducePoints = 0;
calData.ProduceAmounts = 0;
return(calData);
}
private static void BaseExtend(string firstName, PointRulerProductModel pointRulerProduct, KeyValuePair <string, PointRuler> item, ref CalculatePointModel thisCalResult)
{
thisCalResult = CalculatePoint.INEqBase(item.Value, thisCalResult);
pointRulerProduct.CalMethods.Add(new CalMethodModel {
CalMethod = firstName + item.Key, PointChangeLog = thisCalResult.ProducePoints, CalAmount = thisCalResult.ProduceAmounts
});
pointRulerProduct.TotalProducePoints += thisCalResult.ProducePoints;
CalculatePoint.ChangeINCalculatePointModel(thisCalResult);
}
private static void INCheckMultipleRules(ForecastPointModel model, List <KeyValuePair <string, PointRuler> > ListMultiRules, PointRulerProductModel pointRulerProduct)
{
string firstName = "IN_MultipleRules:";
var thisCalResult = new CalculatePointModel {
OldAmounts = model.Amount
};
foreach (var item in ListMultiRules)
{
var Methods = item.Key.Split('_');
if (Methods[0].Equals("BASE"))
{
BaseExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("YEAE") && model.ForecastTime.Year == Convert.ToInt32(Methods[1]))
{
YEAEExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("MONTH") && model.ForecastTime.Month == Convert.ToInt32(Methods[1]))
{
MONTHExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("DAY") && model.ForecastTime.Day == Convert.ToInt32(Methods[1]))
{
DAYExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("WEEK") && (int)model.ForecastTime.DayOfWeek == Convert.ToInt32(Methods[1]))
{
WEEKExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("HOUR") && model.ForecastTime.Hour == Convert.ToInt32(Methods[1]))
{
HOURExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("MINUTE") && model.ForecastTime.Minute == Convert.ToInt32(Methods[1]))
{
MINUTEExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("SECOND") && model.ForecastTime.Minute == Convert.ToInt32(Methods[1]))
{
SECONDExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("YMD") && model.ForecastTime.ToString("yyyyMMdd").Equals(Methods[1]))
{
YMDExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("MD") && model.ForecastTime.ToString("MMdd").Equals(Methods[1]))
{
MDExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("CHINESEMD") && (new ChineseDate(model.ForecastTime).LunarMonth + new ChineseDate(model.ForecastTime).LunarDay).Trim().Equals(Methods[1]))
{
//九月廿三日
CHINESEMDExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("MIWEEKS") && (
model.ForecastTime.Month.ToString().PadLeft(2, '0') +
CalculatePoint.GetWeekNumInMonth(model.ForecastTime).ToString().PadLeft(2, '0') +
((int)model.ForecastTime.DayOfWeek).ToString().PadLeft(2, '0')
).Equals(Methods[1]))
{
MIWEEKSExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
if (Methods[0].Equals("EVENT"))
{
EVENTExtend(firstName, pointRulerProduct, item, ref thisCalResult);
continue;
}
}
}
private static void CHINESEMDExtend(string firstName, PointRulerProductModel pointRulerProduct, KeyValuePair <string, PointRuler> item, CalculatePointModel thisCalResult)
{
thisCalResult = CalculatePoint.OUTEqChineseMD(item.Value, thisCalResult);
pointRulerProduct.CalMethods.Add(new CalMethodModel {
CalMethod = firstName + item.Key, PointChangeLog = thisCalResult.ProducePoints, CalAmount = thisCalResult.ProduceAmounts
});
pointRulerProduct.TotalProducePoints += thisCalResult.ProducePoints;
pointRulerProduct.TotalProduceAmounts += thisCalResult.ProduceAmounts;
CalculatePoint.ChangeOUTCalculatePointModel(thisCalResult);
}
private static void OUTCheckOnlyRule(ForecastPointModel model, List <KeyValuePair <string, PointRuler> > ListOnlyRules, PointRulerProductModel pointRulerProduct, ref bool hasOnlyRules)
{
const string firstName = "OUT_OnlyRule:"; var thisCalResult = new CalculatePointModel {
OldAmounts = model.Amount, OldPoints = model.Points
};
foreach (var item in ListOnlyRules)
{
var Methods = item.Key.Split('_');
if (Methods[0].Equals("BASE"))
{
hasOnlyRules = true;
BaseExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("YEAE") && model.ForecastTime.Year == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
YEAEExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("MONTH") && model.ForecastTime.Month == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
MONTHExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("DAY") && model.ForecastTime.Day == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
DAYExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("WEEK") && (int)model.ForecastTime.DayOfWeek == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
WEEKExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("HOUR") && model.ForecastTime.Hour == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
HOURExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("MINUTE") && model.ForecastTime.Minute == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
MINUTEExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("SECOND") && model.ForecastTime.Minute == Convert.ToInt32(Methods[1]))
{
hasOnlyRules = true;
SECONDExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("YMD") && model.ForecastTime.ToString("yyyyMMdd").Equals(Methods[1]))
{
hasOnlyRules = true;
YMDExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("MD") && model.ForecastTime.ToString("MMdd").Equals(Methods[1]))
{
hasOnlyRules = true;
MDExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("CHINESEMD") && (new ChineseDate(model.ForecastTime).LunarMonth + new ChineseDate(model.ForecastTime).LunarDay).Trim().Equals(Methods[1]))
{
//九月廿三日
hasOnlyRules = true;
CHINESEMDExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("MIWEEKS") && (
model.ForecastTime.Month.ToString().PadLeft(2, '0') +
CalculatePoint.GetWeekNumInMonth(model.ForecastTime).ToString().PadLeft(2, '0') +
((int)model.ForecastTime.DayOfWeek).ToString().PadLeft(2, '0')
).Equals(Methods[1]))
{
hasOnlyRules = true;
MIWEEKSExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
if (Methods[0].Equals("EVENT"))
{
hasOnlyRules = true;
EVENTExtend(firstName, pointRulerProduct, item, thisCalResult);
return;
}
}
}
private static CalculatePointModel OUTAmountNo0(bool deduction, bool plusOrMinus, Int64 point, Int64 amount, int multiple, CalculatePointModel calData)
{
if (point == 0 && multiple != 0)
{
calData.NewPoints = calData.OldPoints;
calData.ProducePoints = 0;
calData.ProduceAmounts = amount * multiple;
calData.NewAmounts = calData.OldAmounts - calData.ProduceAmounts;
if (!deduction && calData.NewAmounts <= 0)
{
calData.ProduceAmounts = 0;
calData.NewAmounts = calData.OldAmounts;
}
return(calData);
}
if (point == 0 && multiple == 0)
{
calData.NewPoints = calData.OldPoints;
calData.ProducePoints = 0;
calData.ProduceAmounts = amount;
calData.NewAmounts = calData.OldAmounts - calData.ProduceAmounts;
if (!deduction && calData.NewAmounts <= 0)
{
calData.ProduceAmounts = 0;
calData.NewAmounts = calData.OldAmounts;
}
return(calData);
}
if (point != 0 && multiple == 0)
{
if (calData.OldPoints == 0)
{
return(calData);
}
var count = calData.OldPoints / point;
if (calData.OldAmounts > 0)
{
for (int i = 0; i < count; i++)
{
if (!deduction && calData.OldAmounts - calData.ProduceAmounts - amount <= 0)
{
break;
}
calData.ProduceAmounts += amount;
calData.ProducePoints += point;
if (!plusOrMinus)
{
calData.ProducePoints -= point;
}
if (calData.OldAmounts - calData.ProduceAmounts <= 0)
{
break;
}
}
}
if (!plusOrMinus)
{
calData.ProducePoints = -calData.ProducePoints;
}
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
calData.NewAmounts = calData.OldAmounts - calData.ProduceAmounts;
return(calData);
}
if (point != 0 && multiple != 0)
{
if (calData.OldPoints == 0)
{
return(calData);
}
var count = calData.OldPoints / point;
if (calData.OldAmounts > 0)
{
for (int i = 0; i < count; i++)
{
calData.ProduceAmounts += amount * multiple;
calData.ProducePoints += point;
if (!plusOrMinus)
{
calData.ProducePoints -= point;
}
if (calData.OldAmounts - calData.ProduceAmounts <= 0)
{
break;
}
}
}
if (!plusOrMinus)
{
calData.ProducePoints = -calData.ProducePoints;
}
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
calData.NewAmounts = calData.OldAmounts - calData.ProduceAmounts;
return(calData);
}
return(calData);
}
private static CalculatePointModel OUTAmount0(bool plusOrMinus, Int64 point, Int64 multiple, CalculatePointModel calData)
{
if (point != 0 && multiple != 0)
{
calData.NewAmounts = calData.OldAmounts;
calData.ProducePoints = point * multiple;
if (!plusOrMinus)
{
calData.ProducePoints = -calData.ProducePoints;
}
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
calData.ProduceAmounts = 0;
return(calData);
}
if (point != 0 && multiple == 0)
{
calData.NewAmounts = calData.OldAmounts;
calData.ProducePoints = point;
if (!plusOrMinus)
{
calData.ProducePoints = -calData.ProducePoints;
}
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
calData.ProduceAmounts = 0;
return(calData);
}
calData.NewPoints = calData.OldPoints;
calData.NewAmounts = calData.OldAmounts;
calData.ProducePoints = 0;
calData.ProduceAmounts = 0;
return(calData);
}
private static CalculatePointModel INPointNo0(bool plusOrMinus, Int64 point, Int64 amount, int multiple, CalculatePointModel calData)
{
if (amount == 0 && multiple != 0)
{
calData.NewAmounts = calData.OldAmounts;
calData.ProduceAmounts = 0;
calData.ProducePoints = point * multiple;
if (!plusOrMinus)
{
calData.ProducePoints = -calData.ProducePoints;
}
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
return(calData);
}
if (amount == 0 && multiple == 0)
{
calData.NewAmounts = calData.OldAmounts;
calData.ProduceAmounts = 0;
calData.ProducePoints = point;
if (plusOrMinus)
{
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
else
{
calData.ProducePoints = -point;
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
return(calData);
}
if (amount != 0 && multiple == 0)
{
var count = calData.OldAmounts / amount;
calData.ProduceAmounts = amount * count;
calData.NewAmounts = calData.OldAmounts - (calData.ProduceAmounts);
calData.ProducePoints = point * count;
if (plusOrMinus)
{
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
else
{
calData.ProducePoints = -calData.ProducePoints;
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
return(calData);
}
if (amount != 0 && multiple != 0)
{
var count = calData.OldAmounts / amount;
calData.ProduceAmounts = amount * count;
calData.NewAmounts = calData.OldAmounts - (calData.ProduceAmounts);
calData.ProducePoints = point * count * multiple;
if (plusOrMinus)
{
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
else
{
calData.ProducePoints = -calData.ProducePoints;
calData.NewPoints = calData.OldPoints + calData.ProducePoints;
}
return(calData);
}
return(calData);
}
