public ReplyController(
IOptions <AppSettingsModel> appSettings,
BlogContext db,
UsersContext udb,
AdminUtil adminUtil,
BlogUtil blogUtil,
ExpUtil expUtil,
MessageUtil msgUtil,
RatingUtil ratingUtil,
IWebHostEnvironment env,
IMemoryCache cache,
ICompositeViewEngine viewEngine,
IActionContextAccessor actionAccessor,
HtmlSanitizerService sanitizerService)
{
_appSettings = appSettings.Value;
_db = db;
_udb = udb;
_adminUtil = adminUtil;
_blogUtil = blogUtil;
_cache = cache;
_env = env;
_expUtil = expUtil;
_ratingUtil = ratingUtil;
_msgUtil = msgUtil;
_viewEngine = viewEngine;
_actionAccessor = actionAccessor;
_sanitizerService = sanitizerService;
}
public AdminController(
IOptions <AppSettingsModel> appSettings,
IOptionsSnapshot <RegisterSettingsModel> regSettings,
IOptionsSnapshot <BackgroundSetting> bgSettings,
IOptionsSnapshot <DataSettingsModel> dataSettings,
BlogContext db,
UsersContext udb,
AdminUtil adminUtil,
CategoryUtil catUtil,
ExpUtil expUtil,
MessageUtil msgUtil,
UserManager <UserProfile> userManager,
IMemoryCache cache,
IWebHostEnvironment env,
IServiceProvider serviceProvider)
{
_db = db;
_udb = udb;
_adminUtil = adminUtil;
_catUtil = catUtil;
_expUtil = expUtil;
_msgUtil = msgUtil;
_appSettings = appSettings.Value;
_regSettings = regSettings.Value;
_bgSettings = bgSettings.Value;
_dataSettings = dataSettings.Value;
_userManager = userManager;
_cache = cache;
_env = env;
_serviceProvider = serviceProvider;
}
public AccountController(
IOptionsSnapshot <RegisterSettingsModel> registerSettings,
BlogContext bdb,
UsersContext udb,
UserManager <UserProfile> userManager,
SignInManager <UserProfile> signInManager,
RoleManager <AspNetCore.Identity.EntityFramework6.IdentityRole> roleManager,
IMemoryCache cache,
ExpUtil expUtil,
ImageUtil imgUtil,
BlogUtil blogUtil,
CategoryUtil catUtil,
EmailSender emailSender)
{
_registerSettings = registerSettings.Value ?? new RegisterSettingsModel();
_db = udb;
_bdb = bdb;
_userManager = userManager;
_signInManager = signInManager;
_roleManager = roleManager;
_expUtil = expUtil;
_imgUtil = imgUtil;
_blogUtil = blogUtil;
_catUtil = catUtil;
_cache = cache;
_emailSender = emailSender;
}
public GameController(UserManager <UserProfile> userManager, UsersContext udb, ExpUtil expUtil, IAuthorizationService authorizationService)
{
_userManager = userManager;
_udb = udb;
_expUtil = expUtil;
_authorizationService = authorizationService;
}
public TreasureHuntController(
UsersContext udb, IMemoryCache cache, INickNameProvider nickNameProvider, ExpUtil expUtil)
{
_udb = udb;
_cache = cache;
_nickNameProvider = nickNameProvider;
_expUtil = expUtil;
}
public GachaController(UsersContext db, IMemoryCache cache, ExpUtil expUtil, GachaBonusService gachaBonus)
{
db_ = db;
cache_ = cache;
expUtil_ = expUtil;
random_ = new Random();
gachaBonus_ = gachaBonus;
}
public RaffleController(
UsersContext udb,
UserManager<UserProfile> userManager,
ExpUtil expUtil)
{
_udb = udb;
_expUtil = expUtil;
_userManager = userManager;
}
public async Task <JsonResult> Login([FromServices] BlogUtil util, [FromBody] LoginModel model)
{
if (util.CheckCaptchaError(model.Captcha, ""))
{
ModelState.AddModelError("Captcha", "验证码计算错误，请重试。");
}
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
if (await _userManager.IsInRoleAsync(user, "Banned"))
{
return(Json(new
{
success = false,
errors = new[] { "此账户已被封禁，如有疑问请联系管理员邮箱。" },
}));
}
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
user.LastLoginDate = DateTime.Now;
user.LastLoginIP = ExpUtil.GetIPAddress(HttpContext);
await _userManager.UpdateAsync(user);
return(Json(new { success = true }));
}
if (result.IsLockedOut)
{
return(Json(new
{
success = false,
errors = new[] { "此账户由于登陆尝试次数过多已被暂时锁定，请稍后再试。" },
}));
}
else if (result.RequiresTwoFactor)
{
return(Json(new
{
success = true,
require2fa = true,
}));
}
}
// 如果我们进行到这一步时某个地方出代楷则重新显示表单
ModelState.AddModelError("", "提供的用户名或密码不正确");
}
return(Json(new {
success = false,
errors = ModelState.Values.SelectMany(m => m.Errors).Select(e => e.ErrorMessage).ToList()
}));
}
private void FillMaterails()
{
if (m_maxLimitIntentifyInfo == null)
{
return;
}
int needExp = m_maxLimitIntentifyInfo.exp - data.GetCurrentTotalExp();
m_swallowMats = ExpUtil.GetValidPItems(moduleEquip.GetBagProps((PropType.IntentyProp)), (uint)needExp);
}
public WheelController(
UsersContext udb,
UserManager <UserProfile> userManager,
ExpUtil expUtil,
IOptionsSnapshot <WheelConfig> options)
{
_udb = udb;
_expUtil = expUtil;
_userManager = userManager;
_wheelConfig = options;
}
public RaffleController(
IOptions <RaffleConfig> config,
UsersContext udb,
UserManager <UserProfile> userManager,
ExpUtil expUtil)
{
_udb = udb;
_expUtil = expUtil;
_userManager = userManager;
_config = config;
}
////我把第一篇论文的实验数据的子式写入数据库吧
//public void Test3()
//{
// // LaTeX，子式节点
// Dictionary<AAAAData, List<String>> dic = new Dictionary<AAAAData, List<String>>();
// StreamReader sr = new StreamReader("C:\\Users\\dell\\Desktop\\暑假\\实验数据\\1.txt", Encoding.Default);
// String read = sr.ReadLine();
// //第一步：开始读取每一个数学表达式了啊
// while (read != null)
// {
// //第二步：直接构成倒排索引吧，省的以后要是有重复的数学表达式啥的
// //对于输入进来的每一个数学公式，把它解析为各个子式
// List<AAAAData> li = new List<AAAAData>();
// li = Test4(read);
// int biaozhi = 0;//每进来一个子式，就记作一个标志
// //对于每一个子式节点，我需要插入字典，作为倒排索引
// foreach (var it in li)
// {
// //if (dic.Count == 0)
// //{
// // List<String> list = new List<string>();
// // list.Add(read);
// // dic.Add(it,list);
// // Console.WriteLine("第一个if");
// //}
// //else
// //{
// // //我去遍历字典的键值对象
// // foreach (var zidian in dic)
// // {
// // //如果字典里面的倒排索引有某一个子式了
// // if (zidian.Key.Equals(it) && (biaozhi == 0))
// // {
// // Console.WriteLine("第二个if");
// // dic[zidian.Key].Add(read);
// // biaozhi++;
// // }
// // else if(!zidian.Key.Equals(it))
// // {
// // List<String> list = new List<string>();
// // list.Add(read);
// // dic.Add(it, list);
// // }
// // }
// //}
// //==========================================================
// if (dic.Count == 0)
// {
// List<String> list = new List<string>();
// list.Add(read);
// dic.Add(it, list);
// continue;
// }
// int a = 0;//这是个判断标志，下面开始遍历，如果找到，那么a=1，没找到a=0
// AAAAData tempKey = null;//定义临时键存储文件名字
// foreach (var item in dic)
// {
// if (item.Key.Equals(it))
// {
// a = 1;
// tempKey = item.Key;//其实不用定义,因为如果找到，indexes.FileName与item.Key相等，下面那个“[]中括号”找谁不都一样么，多此一举
// break;//一旦找到说明找到了，那么就可以终止了，此时等于一加个break，否则又出bug了
// }
// }
// if (a == 1)//说明找到了
// {
// dic[tempKey].Add(read);
// }
// else if (a == 0)//说明没找到
// {
// List<String> list = new List<string>();
// list.Add(read);
// dic.Add(it, list);
// }
// //==========================================================
// }//循环里面
// read = sr.ReadLine();
// }
// ////这里把数据倒排插入数据库
// //bool panduan;
// //string sqlstr = "insert into Test1(子式,子式所在高度,数学表达式) values ('" + node + "','" + filename + "','" + path + "')";
// //panduan = DBhelper.InsertUpdateDal(sqlstr);
// //if (panduan == true)
// //{
// // Console.Write("操作成功");
// //}
// //else
// //{
// // Console.Write("操作失败");
// //}
//}
//我先试一试获取数学表达式子式
public List <AAAAData> Test4(String LaTeX)
{
List <AAAAData> list = new List <AAAAData>();
ExpUtil exputil = new ExpUtil();
List <NodeInfo> temp = exputil.GetNodeList(LaTeX, 0);
//定义一个字典，Key是层次，Value是每一层的子式
return(list);
}
public PunchInController(
UsersContext udb,
ExpUtil expUtil,
IOptions <AppSettingsModel> appSettings,
IMemoryCache cache,
IHttpContextAccessor contextAccessor,
INickNameProvider nickNameProvider)
{
_udb = udb;
_nickNameProvider = nickNameProvider;
_expUtil = expUtil;
_appSettings = appSettings.Value;
_cache = cache;
_contextAccessor = contextAccessor;
}
private void GetExpDatas()
{
List <IExp> data = ExpUtil.GetValidExps(currenProps, (uint)totalExp);
int realExp = 0;
sb.AppendLine("Get props:");
foreach (var item in data)
{
PropItemInfo prop = item as PropItemInfo;
sb.AppendLine(Util.Format("id : {0} exp : {1} use num : {2}", prop.ID, prop.gainExp, item.useNum));
realExp += (int)prop.gainExp * item.useNum;
}
sb.AppendLine("-----------------------------------------------------------------");
sb.AppendLine(Util.Format("set total exp : {0} select item total Exp :{1}", totalExp, realExp));
Logger.LogWarning(sb.ToString());
}
public ReplyController(
IOptions <AppSettingsModel> appSettings,
BlogContext db,
UsersContext udb,
AdminUtil adminUtil,
BlogUtil blogUtil,
ExpUtil expUtil,
MessageUtil msgUtil,
RatingUtil ratingUtil,
HtmlSanitizerService sanitizerService)
{
_appSettings = appSettings.Value;
_db = db;
_udb = udb;
_adminUtil = adminUtil;
_blogUtil = blogUtil;
_expUtil = expUtil;
_ratingUtil = ratingUtil;
_msgUtil = msgUtil;
_sanitizerService = sanitizerService;
}
public async Task <IActionResult> Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
if (await _userManager.IsInRoleAsync(user, "Banned"))
{
ModelState.AddModelError("", "此账户已被封禁，如有疑问请联系管理员。");
return(View());
}
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
user.LastLoginDate = DateTime.Now;
user.LastLoginIP = ExpUtil.GetIPAddress(HttpContext);
await _userManager.UpdateAsync(user);
return(RedirectToLocal(returnUrl));
}
if (result.IsLockedOut)
{
return(RedirectToAction("Lockout"));
}
else if (result.RequiresTwoFactor)
{
return(RedirectToAction(nameof(TwoFactorAuth), new { ReturnUrl = returnUrl }));
}
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
ModelState.AddModelError("", "提供的用户名或密码不正确。");
}
return(View(model));
}
public HomeController(
IOptions <AppSettingsModel> appSettings,
IOptionsSnapshot <DataSettingsModel> dataSettings,
BlogContext db,
UsersContext udb,
AdminUtil adminUtil,
BlogUtil blogUtil,
CategoryUtil catUtil,
ExpUtil expUtil,
MessageUtil msgUtil,
TagUtil tagUtil,
UserManager <UserProfile> userManager,
UploadUtil uploadUtil,
RatingUtil ratingUtil,
CacheService cacheService,
IMemoryCache cache,
IWebHostEnvironment env,
ISearchProvider searchProvider)
{
_db = db;
_udb = udb;
_adminUtil = adminUtil;
_catUtil = catUtil;
_blogUtil = blogUtil;
_expUtil = expUtil;
_msgUtil = msgUtil;
_appSettings = appSettings.Value;
_dataSettings = dataSettings.Value;
_userManager = userManager;
_cache = cache;
_uploadUtil = uploadUtil;
_tagUtil = tagUtil;
_ratingUtil = ratingUtil;
_cacheService = cacheService;
_env = env;
_searchProvider = searchProvider;
}
public GameController(UsersContext udb, ExpUtil expUtil)
{
_udb = udb;
_expUtil = expUtil;
}
public async Task <ActionResult> Do([FromHybrid] PunchInRequest request)
{
var user = await _udb.Users.Include(u => u.PunchIns).SingleOrDefaultAsync(u => u.UserName == User.Identity.Name);
var d = request.Date.GetValueOrDefault(DateTime.Now);
if (d.Date > DateTime.Today || d.Date < ExpUtil.FirstSignHistoryDate || d.Date < user.CreateDate.Date)
{
return(BadRequest(new PunchInResult
{
Success = false,
ErrorMessage = "日期无效",
ConsecutiveDays = user.ConsecutiveSign,
Points = user.Points
}));
}
if (user.PunchIns == null)
{
user.PunchIns = new List <PunchInHistory>();
}
else if (user.PunchIns.Any(p => p.TimeStamp.Date == d.Date))
{
return(BadRequest(new PunchInResult
{
Success = false,
ErrorMessage = "此日已签",
ConsecutiveDays = user.ConsecutiveSign,
Points = user.Points
}));
}
var today = DateTime.Now;
bool isMakeup = d.Date != today.Date;
int consecutive = 0;
if (isMakeup)
{
if (request.UseTicket)
{
if (user.quest.PunchInTicket > 0)
{
user.quest.PunchInTicket--;
}
else
{
return(BadRequest(new PunchInResult
{
Success = false,
ErrorMessage = "补签券不足",
ConsecutiveDays = user.ConsecutiveSign,
Points = user.Points
}));
}
}
else
{
int cost = MakeUpCost(d.Date);
if (user.Points < cost)
{
return(BadRequest(new PunchInResult
{
Success = false,
ErrorMessage = "棒棒糖不足",
ConsecutiveDays = user.ConsecutiveSign,
Points = user.Points
}));
}
user.Points -= cost;
}
}
else
{
user.LastSignDate = today;
}
user.PunchIns.Add(new PunchInHistory {
UserID = user.Id, IsMakeup = isMakeup, TimeStamp = isMakeup ? d : today
});
var lastDay = user.PunchIns.Max(u => u.TimeStamp).Date;
foreach (var t in user.PunchIns.OrderByDescending(h => h.TimeStamp))
{
if (t.TimeStamp.Date > lastDay)
{
continue;
}
if (t.TimeStamp.Date != lastDay)
{
break;
}
consecutive++;
lastDay = lastDay.AddDays(-1);
}
if (lastDay < ExpUtil.FirstSignHistoryDate)
{
consecutive += user.HistoryConsecutiveSign;
}
user.ConsecutiveSign = consecutive;
List <int> days = _appSettings.ExpAddOnDay;
int exp = 0;
if (!isMakeup && days != null && days.Count > 0)
{
if (user.ConsecutiveSign > days.Count)
{
exp = days.Last();
}
else
{
exp = days[user.ConsecutiveSign - 1];
}
_expUtil.addExp(user, exp);
}
user.LastLoginIP = ExpUtil.GetIPAddress(HttpContext);
await _udb.SaveChangesAsync();
_cache.Remove(ExpUtil.SignCacheKey + user.UserName.ToLower());
return(Json(new PunchInResult {
Success = true, ConsecutiveDays = user.ConsecutiveSign, ExpBonus = exp, Points = user.Points
}));
}
public async Task <IActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid && AllowRegister())
{
if (_registerSettings.RegisterQuestionEnabled && _registerSettings.RegisterQuestions != null && _registerSettings.RegisterQuestions.Count > 0)
{
var questions = _registerSettings.RegisterQuestions;
if (model.RegisterQuestionIndex < 0 || model.RegisterQuestionIndex >= questions.Count)
{
ModelState.AddModelError("RegisterAnswer", "请重新回答注册问题");
Random r = new Random();
model.RegisterQuestionIndex = r.Next(questions.Count);
return(View(model));
}
else if (!questions[model.RegisterQuestionIndex].Answer.Equals(model.RegisterAnswer, StringComparison.OrdinalIgnoreCase))
{
ModelState.AddModelError("RegisterAnswer", "回答错误");
return(View(model));
}
}
if (string.IsNullOrWhiteSpace(model.NickName))
{
model.NickName = model.UserName;
if (CheckNickName(model.NickName) != null)
{
ModelState.SetModelValue("NickName", new ValueProviderResult(model.UserName));
ModelState.AddModelError("NickName", "昵称已被使用，请更改。");
return(View(model));
}
}
Guid code = new Guid();
if (_registerSettings.RequireCode)
{
if (!Guid.TryParse(model.RegisterCode, out code) || !_db.UserCodes.Any(c => c.UsedBy == null && c.Code == code))
{
ModelState.AddModelError("RegisterCode", "无效的邀请码");
return(View(model));
}
}
// 尝试注册用户
var user = new UserProfile
{
UserName = model.UserName,
NickName = model.NickName,
Email = model.Email,
LastLoginIP = ExpUtil.GetIPAddress(HttpContext),
LastLoginDate = DateTime.Now,
CreateDate = DateTime.Now,
Points = 0,
ConsecutiveSign = 0,
Experience = 1,
Level = 1,
LastSignDate = System.Data.SqlTypes.SqlDateTime.MinValue.Value,
};
var createResult = await _userManager.CreateAsync(user, model.Password);
if (createResult.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
if (_registerSettings.RequireCode)
{
_db.UserCodes.Find(code).UsedBy = user.Id;
_db.SaveChanges();
}
if (model.avatar != null)
{
byte[] fileData = null;
using (var reader = new BinaryReader(model.avatar.OpenReadStream()))
{
fileData = reader.ReadBytes((int)model.avatar.Length);
_imgUtil.AddPic(model.UserName, model.avatar.ContentType, _imgUtil.Crop(fileData, model.W, model.H, model.X, model.Y));
}
}
return(RedirectToAction("Index", "Home"));
}
AddErrors(createResult);
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
return(View(model));
}
public List <FinalNode1> FuZhi(List <FinalNode1> finalList1, String LaTeX)
{
ExpUtil exputil = new ExpUtil();
//Console.WriteLine("FuZhiFeature:传进来的LaTeX为:" + LaTeX);
if (LaTeX.Contains("\\lim") || LaTeX.Contains("\\sum"))//如果含有lim的话，这个是含有lim的得特殊处理啊
{
//Console.WriteLine("FuZhiFeature:传进来的LaTeX为:" + LaTeX);
LaTeX = LaTeX.Replace("\\join", "");
LaTeX = LaTeX.Replace("\\connect", "");
LaTeX = LaTeX.Replace("\\negative*", "-");
LaTeX = LaTeX.Replace("\\negative", "-");
LaTeX = LaTeX.Replace("\\PowerRoot", "");
LaTeX = LaTeX.Replace("\\DuiShu", "");
LaTeX = LaTeX.Replace("\\temp", "\\log_");
//Console.WriteLine("替换后的LaTeX为:" + LaTeX);
char[] limcaos = LaTeX.ToCharArray();
LaTeX = "";
for (int d = 0; d < limcaos.Length; d++)
{
if (Convert.ToString(limcaos[d]).Equals("\\") && Convert.ToString(limcaos[d + 1]).Equals("l") && Convert.ToString(limcaos[d + 2]).Equals("i") && Convert.ToString(limcaos[d + 3]).Equals("m"))
{
//下面这个下标是为了使杨颂强那个给解析出特征然后赋给我啊，而我那个里面没有任何变动
LaTeX = LaTeX + "\\lim_";
d = d + 3;
}
else if (Convert.ToString(limcaos[d]).Equals("\\") && Convert.ToString(limcaos[d + 1]).Equals("s") && Convert.ToString(limcaos[d + 2]).Equals("u") && Convert.ToString(limcaos[d + 3]).Equals("m"))
{
LaTeX = LaTeX + "\\sum_";
d = d + 3;
}
else
{
LaTeX = LaTeX + Convert.ToString(limcaos[d]);
}
}
//Console.WriteLine("FuZhiFeature:处理的差不多了LaTeX:" + LaTeX);
//============================================1、需要弄一系列特征，和杨颂强依次对应比较============================================
List <NodeInfo> temps = exputil.GetNodeList(LaTeX, 0);
if (finalList1[finalList1.Count - 1].zifu.Equals("\\join") || finalList1[finalList1.Count - 1].zifu.Equals("\\connect"))//如果最后一个元素是“\\join”或者是“\\connect”
{
List <FinalNode1> tempFinalist = new List <FinalNode1>();
for (int e = 0; e < finalList1.Count - 1; e++)
{
tempFinalist.Add(finalList1[e]);
}
finalList1 = tempFinalist;
}
/*foreach (var it in temps)
* {
* Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
* }
*
* foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//Console.WriteLine("需要弄一系列特征的打印结果，所以先按原始序号，因此需要按照杨颂强那个顺序依次进行比较");
int c = 0;
for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
{
if (temps[c].nodeexp.Equals("(") || temps[c].nodeexp.Equals(")") || temps[c].nodeexp.Equals("[") || temps[c].nodeexp.Equals("]"))
{
//Console.WriteLine("执行了没啊:");
c++;
a--;
continue;
}
else if (finalList1[a].zifu.Equals(temps[c].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
{
//既然遇到了“上标”或者“下标”，那就对它进行处理么
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
Console.WriteLine("现在字符：" + finalList1[a].zifu + "\t" + "杨颂强字符：" + temps[c].nodeexp);
}
//这个是下面那个含有以谁为底，以其它为对数的
else if (finalList1[a].zifu.Equals("\\temp") && temps[c].nodeexp.Equals("\\log") && temps[c + 1].flag == 4)
{
//Console.WriteLine("怎么不能执行呢？");
finalList1[a].zifu = temps[c].nodeexp;
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
//实际上没有下面的这个判断也行啊，也就是弄了半天，我就是把原来那个要解析的杨颂强的那个\\lim_这个极限符号给它加个下划线“_”，这样才能解析得到杨颂强的各项特征
//从而把各项特征传过来，传到我的这里啊
else if (finalList1[a].zifu.Equals("\\join") || finalList1[a].zifu.Equals("\\connect") || finalList1[a].zifu.Equals("\\PowerRoot"))
{
continue;
}
else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
finalList1[a + 1].Level = temps[c].level;
finalList1[a + 1].Flag = temps[c].flag;
finalList1[a + 1].Length = finalList1.Count;
a++;
c++;
}
else if (a < finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
}
//用个栈来存放\lim元素，类似于左括号，我的\join是右括号
Stack <FinalNode1> stack = new Stack <FinalNode1>();
foreach (var it in finalList1)
{
if (it.zifu.Equals("\\lim"))//相当于左括号
{
stack.Push(it);
}
else if (it.zifu.Equals("\\join"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack.Pop();//把栈里面的\lim给弹出来
it.Level = tem.Level;
it.Flag = tem.Flag;
}
}
/*foreach (var it in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs就差\\sum了啊:" + it.zifu + "\t" + "Level:" + it.Level + "\t" + "Flag:" + it.Flag);
* }*/
//用个栈来存放\sum元素，类似于左括号，我的“^”是右括号，先这么个简单的啊，我这里规定\sum的那个connect是与“上标的那个特征是一样的”
Stack <FinalNode1> stack1 = new Stack <FinalNode1>();
foreach (var it in finalList1)
{
if (it.zifu.Equals("\\sum"))//相当于左括号
{
//Console.WriteLine("==========尼玛执行了吗1");
stack1.Push(it);
continue;
}
else if (stack1.Count == 1 && it.zifu.Equals("^") && stack1.Peek().zifu.Equals("\\sum"))
{
//Console.WriteLine("草你妈了个比");
stack1.Push(it);
continue;
}
else if (stack1.Count == 2 && it.zifu.Equals("\\connect") && stack1.Peek().zifu.Equals("^"))//此时仅仅有\\sum和第一个“^”
{
//Console.WriteLine("====================================尼玛执行了吗3");
FinalNode1 tem = new FinalNode1();
tem = stack1.Pop();//把栈里面的"^"给弹出来
it.Level = tem.Level;
it.Flag = tem.Flag;
Console.WriteLine("第三个：字符" + it.zifu + "\t" + "空间标志位：" + it.Flag + "\t" + "第三个：字符" + tem.zifu + "\t" + "空间标志位：" + tem.Flag);
stack1.Pop();
continue;
}
}
/*foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
Stack <FinalNode1> stack2 = new Stack <FinalNode1>();
for (int i = 0; i < finalList1.Count; i++)
{
if (finalList1[i].zifu.Equals("\\sqrt") && finalList1[i + 1].Flag == 7)//当前是根号，且和它相邻的下一个的字符flag为左上标，说明当前的这个根号是N次方根的那种
{
//Console.WriteLine("压入了几次啊");
stack2.Push(finalList1[i]);
}
else if (finalList1[i].zifu.Equals("\\PowerRoot"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack2.Pop();//把栈里面的\\PowerRoot给弹出来
finalList1[i].Level = tem.Level;
finalList1[i].Flag = tem.Flag;
}
}
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
/*Stack<FinalNode1> stack2 = new Stack<FinalNode1>();
* foreach (var it in finalList1)
* {
* if (it.zifu.Equals("\\sqrt"))//相当于左括号
* {
* stack2.Push(it);
* }
* else if (it.zifu.Equals("\\join"))//相当于右括号,遇到右括号的话
* {
* FinalNode1 tem = new FinalNode1();
* tem = stack2.Pop();//把栈里面的\lim给弹出来
* it.Level = tem.Level;
* it.Flag = tem.Flag;
* }
* }*/
//foreach (var it in finalList1)
//{
// Console.WriteLine("FuZhiFeature.cs:"+it.zifu+"\t"+"Level:"+it.Level+"\t"+"Flag:"+it.Flag);
//}
}//含有特殊字符lim和sum的处理啊
//else if (LaTeX.Contains("\\negative"))
//{
// LaTeX = LaTeX.Replace("\\negative*", "-");
// LaTeX = LaTeX.Replace("\\negative", "-");
// List<NodeInfo> temps = exputil.GetNodeList(LaTeX, 0);
// foreach (var it in temps)
// {
// Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
// }
// foreach (var itt in finalList1)
// {
// Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
// }
// int c = 0;
// for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
// {
// if (finalList1[a].zifu.Equals(temps[c].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
// {
// //既然遇到了“上标”或者“下标”，那就对它进行处理么
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// }
// //下面这种情况是数学表达式：“-\\frac{a}{b}”，对应的
// /*
// 我： \negative * \frac a b
// 杨： - \frac a b
// */
// else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// finalList1[a + 1].Level = temps[c].level;
// finalList1[a + 1].Flag = temps[c].flag;
// finalList1[a + 1].Length = finalList1.Count;
// a++;
// c++;
// }
// else if (a<finalList1.Count-1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// }
//}
else
{
LaTeX = LaTeX.Replace("\\negative*", "-");
LaTeX = LaTeX.Replace("\\negative", "-");
LaTeX = LaTeX.Replace("\\PowerRoot", "");
LaTeX = LaTeX.Replace("\\DuiShu", "");
LaTeX = LaTeX.Replace("\\temp", "\\log_");
//Console.WriteLine("FuZhiFeature.cs:卧槽===========:" + LaTeX);
//======================================下面这个是最一般字符的处理，不用管了，之前已经验证了========================================================
//============================================1、需要弄一系列特征，和杨颂强依次对应比较============================================
List <NodeInfo> temp = exputil.GetNodeList(LaTeX, 0);
//Console.WriteLine("草拟吗："+LaTeX);
/*foreach (var it in temp)
* {
* Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
* }
*
* foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//Console.WriteLine("需要弄一系列特征的打印结果，所以先按原始序号，因此需要按照杨颂强那个顺序依次进行比较");
int b = 0;
for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
{
if (temp[b].nodeexp.Equals("(") || temp[b].nodeexp.Equals(")") || temp[b].nodeexp.Equals("[") || temp[b].nodeexp.Equals("]"))
{
//Console.WriteLine("执行了没啊:");
b++;
a--;
continue;
}
else if (finalList1[a].zifu.Equals(temp[b].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
/////////////////////////////////////////////Console.WriteLine("第一个b"+b);
}
//=======================================！！！！！！！！！！！！！！！！！！！！下面这个是改上下标啊=================================================
else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
{
//既然遇到了“上标”或者“下标”，那就对它进行处理么
/////////////////////////////////Console.WriteLine("================b"+b);
//Console.WriteLine("原始字符："+finalList1[a].zifu);
// Console.WriteLine("杨颂强字符：" + temp[b].nodeexp);
finalList1[a].Level = temp[b - 1].level;
finalList1[a].Flag = temp[b - 1].flag;
finalList1[a].Length = finalList1.Count;
//////////////////////////////////Console.WriteLine("FuZhiFeature.cs第二个：原始字符"+ finalList1[a].zifu + "\t" + "空间标志为：" + finalList1[a].Flag + "第二个：杨颂强字符" + temp[b].nodeexp + "\t" + "空间标志为：" + temp[b].flag);
}
//=======================================！！！！！！！！！！！！！！！！！下面这个是改上下标啊=================================================
else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
finalList1[a + 1].Level = temp[b].level;
finalList1[a + 1].Flag = temp[b].flag;
finalList1[a + 1].Length = finalList1.Count;
a++;
b++;
}
else if (a < finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\temp") && temp[b].nodeexp.Equals("\\log") && temp[b + 1].flag == 4)
{
//Console.WriteLine("怎么不能执行呢？");
finalList1[a].zifu = temp[b].nodeexp;
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\PowerRoot") || finalList1[a].zifu.Equals("\\DuiShu"))
{
continue;
}
}
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
Stack <FinalNode1> stack2 = new Stack <FinalNode1>();
for (int i = 0; i < finalList1.Count; i++)
{
if (finalList1[i].zifu.Equals("\\sqrt") && finalList1[i + 1].Flag == 7)//当前是根号，且和它相邻的下一个的字符flag为左上标，说明当前的这个根号是N次方根的那种
{
stack2.Push(finalList1[i]);
}
else if (finalList1[i].zifu.Equals("\\PowerRoot"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack2.Pop();//把栈里面的\lim给弹出来
finalList1[i].Level = tem.Level;
finalList1[i].Flag = tem.Flag;
}
}
}//一般字符
return(finalList1);
}
