TEAMModelOS/TEAMModelOS.SDK/Models/Service/SchoolService.cs

using Azure.Cosmos;
using Azure.Storage.Blobs.Models;
using DocumentFormat.OpenXml.Bibliography;
using DocumentFormat.OpenXml.Drawing.Charts;
using HTEXLib.COMM.Helpers;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.International.Converters.PinYinConverter;
using Microsoft.International.Converters.TraditionalChineseToSimplifiedConverter;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TEAMModelOS.Models;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using Period = TEAMModelOS.SDK.Models.Period;

namespace TEAMModelOS.SDK
{
    public class SchoolService
    {

        public static async Task<School> ModifySchool(School school, AzureCosmosFactory _azureCosmos) {

            //修补五育的科目关联
            var subjects = school.period.SelectMany(x => x.subjects).Where(y => (!string.IsNullOrWhiteSpace(y.bindId) &&
            (y.bindId.Equals("subject_painting")  || y.bindId.Equals("subject_sport")
            || y.bindId.Equals("subject_labour") ||  y.bindId.Equals("subject_virtue") || y.bindId.Equals("subject_music")

              || y.bindId.Equals("subject_chinese") ||  y.bindId.Equals("subject_math") || y.bindId.Equals("subject_english")
                || y.bindId.Equals("subject_physics") ||  y.bindId.Equals("subject_chemistry") || y.bindId.Equals("subject_biology")
                  || y.bindId.Equals("subject_politics") ||  y.bindId.Equals("subject_history") || y.bindId.Equals("subject_geography")

            ))
            || y.name.Contains("音乐") || y.name.Contains("美术") || y.name.Contains("劳动") ||  y.name.Contains("德育")  ||  y.name.Contains("体育")
              || y.name.Contains("语文") || y.name.Contains("数学") || y.name.Contains("英语") ||  y.name.Contains("物理")  ||  y.name.Contains("化学")
                || y.name.Contains("生物") || y.name.Contains("政治") || y.name.Contains("历史") ||  y.name.Contains("地理")
            );
            if (subjects.Any())
            {
                bool change = false;
                foreach (var subject in subjects)
                {
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("语文"))
                    {
                        subject.bindId="subject_chinese";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("数学"))
                    {
                        subject.bindId="subject_math";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("英语"))
                    {
                        subject.bindId="subject_english";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("物理"))
                    {
                        subject.bindId="subject_physics";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("化学"))
                    {
                        subject.bindId="subject_chemistry";
                        change= true;
                    }

                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("生物"))
                    {
                        subject.bindId="subject_biology";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("政治"))
                    {
                        subject.bindId="subject_politics";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("历史"))
                    {
                        subject.bindId="subject_history";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("地理"))
                    {
                        subject.bindId="subject_geography";
                        change= true;
                    }

                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("音乐"))
                    {
                        subject.bindId="subject_music";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("美术"))
                    {
                        subject.bindId="subject_painting";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("劳动"))
                    {
                        subject.bindId="subject_labour";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("德育"))
                    {
                        subject.bindId="subject_virtue";
                        change= true;
                    }
                    if (string.IsNullOrWhiteSpace(subject.bindId)  && subject.name.Contains("体育"))
                    {
                        subject.bindId="subject_sport";
                        change= true;
                    }
                }
                //{
                //    List<Period> periods = new List<Period>();
                //    var hastype_period = school.period.Where(p => !string.IsNullOrWhiteSpace(p.periodType));
                //    if (hastype_period.Any())
                //    {
                //        periods.AddRange(hastype_period);
                //    }
                //    var nottype_period = school.period.Where(p => string.IsNullOrWhiteSpace(p.periodType));
                //    if (nottype_period!=null && nottype_period.Count()>0)
                //    {
                //        foreach (var period in nottype_period)
                //        {
                //            if (period.name.Contains("小学"))
                //            {
                //                change= true;
                //                period.periodType= "primary";
                //            }
                //            if (period.name.Contains("初中"))
                //            {
                //                change= true;
                //                period.periodType = "junior";
                //            }
                //            if (period.name.Contains("高中"))
                //            {
                //                change= true;
                //                period.periodType = "senior";
                //            }
                //            if (string.IsNullOrWhiteSpace(period.periodType) && school.period.Count == 1)
                //            {
                //                if (school.name.Contains("小学"))
                //                {
                //                    change= true;
                //                    period.periodType = "primary";

                //                }
                //                if (school.name.Contains("初中"))
                //                {
                //                    change= true;
                //                    period.periodType = "junior";
                //                }
                //                if (school.name.Contains("高中"))
                //                {
                //                    change= true;
                //                    period.periodType = "senior";
                //                }
                //            }
                //            if (!string.IsNullOrWhiteSpace(period.periodType))
                //            {
                //                periods.Add(period);
                //            }
                //        }
                //    }
                //}
                if (change)
                {
                    School schoolSelf = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.School).UpsertItemAsync<School>(school, new PartitionKey("Base"));
                }
            }
            return school;
        }

        public static async Task<(int code, string msg, object data)> JoinScool(string school, string id, string name, string picture, long ts,
            AzureCosmosFactory _azureCosmos,AzureStorageFactory _azureStorage,CoreAPIHttpService _coreAPIHttpService,DingDing _dingDing,Option _option,IConfiguration _configuration, IWebHostEnvironment _environment)
        {

            SchoolTeacher schoolTeacher = null;
            School schoolInfo = null;
            long nowTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            try
            {

                if (nowTime - ts > 3600000)
                {
                    return (1, "超时!", null);
                }
                var client = _azureCosmos.GetCosmosClient();

                try
                {
                    schoolInfo = await client.GetContainer(Constant.TEAMModelOS, "School").ReadItemAsync<School>($"{school}", new PartitionKey("Base"));
                }
                catch (CosmosException ex)
                {
                    if (ex.Status == 404)
                    {
                        return (2, "该学校不存在!", null);
                    }
                }
                Teacher teacher = null;
                try
                {
                    teacher = await client.GetContainer(Constant.TEAMModelOS, "Teacher").ReadItemAsync<Teacher>($"{id}", new PartitionKey("Base"));
                    var sch = teacher.schools.Find(x => x.schoolId.Equals($"{school}"));
                    if (sch != null)
                    {
                        if (sch.status.Equals("join"))
                        {
                            return (3, "该教师之前已经加入学校!", null);
                        }
                        else
                        {
                            sch.status = "join";
                            sch.time = nowTime;
                            sch.name = schoolInfo?.name;
                            sch.picture = schoolInfo?.picture;
                            sch.areaId = schoolInfo?.areaId;
                        }
                    }
                    else
                    {
                        teacher.schools.Add(new Teacher.TeacherSchool { areaId = schoolInfo?.areaId, schoolId = schoolInfo.id, status = "join", name = schoolInfo.name, picture = schoolInfo.picture, time = nowTime });
                    }
                    if (teacher.size < 2)
                    {
                        teacher.size = 2;
                    }
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").ReplaceItemAsync<Teacher>(teacher, teacher.id, new PartitionKey($"Base"));
                }
                catch (CosmosException ex)
                {
                    if (ex.Status == 404)
                    {
                        //如果沒有，則初始化Teacher基本資料到Cosmos
                        teacher = new Teacher
                        {
                            createTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                            id = id,
                            pk = "Base",
                            code = "Base",
                            name = name?.ToString(),
                           // picture = picture?.ToString(),
                            //创建账号并第一次登录IES5则默认赠送1G
                            defaultSchool = null,
                            size = 2,
                            schools = new List<Teacher.TeacherSchool>() { new Teacher.TeacherSchool { areaId = schoolInfo?.areaId, schoolId = schoolInfo.id, status = "join", name = schoolInfo.name, picture = schoolInfo.picture, time = nowTime } }
                        };
                        var container = _azureStorage.GetBlobContainerClient(id);
                        await container.CreateIfNotExistsAsync(PublicAccessType.None); //嘗試創建Teacher私有容器，如存在則不做任何事，保障容器一定存在
                        await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "Teacher").CreateItemAsync<Teacher>(teacher, new PartitionKey("Base"));
                    }
                }

                Azure.Response response = await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync(teacher.id, new PartitionKey($"Teacher-{schoolInfo.id}"));
                if (response.Status != 200)
                {
                    schoolTeacher = new SchoolTeacher
                    {
                        id = teacher.id,
                        pk = "Teacher",
                        name = teacher.name,
                        picture = teacher.picture,
                        size = 0,
                        roles = new List<string> { "teacher" },
                        permissions = new List<string>(),
                        status = "join",
                        createTime = nowTime,
                        code = $"Teacher-{schoolInfo.id}",
                        ttl = -1
                    };
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<SchoolTeacher>(schoolTeacher, new PartitionKey($"Teacher-{schoolInfo.id}"));
                }
                else
                {
                    JsonElement data = JsonDocument.Parse(response.ContentStream).RootElement;
                    schoolTeacher = data.ToObject<SchoolTeacher>();
                    schoolTeacher.status = "join";
                    schoolTeacher.name = schoolInfo.name;
                    schoolTeacher.picture = schoolInfo.picture;
                    await _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<SchoolTeacher>(schoolTeacher, schoolTeacher.id, new PartitionKey($"Teacher-{schoolInfo.id}"));
                }

                //通知管理员
                string sql = "select distinct  value(c.id) from c where array_contains(c.roles,'admin')";
                List<string> ids = new List<string>();
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<string>(queryText: sql,
                                requestOptions: new QueryRequestOptions() { PartitionKey = new Azure.Cosmos.PartitionKey($"Teacher-{school}") }))
                {
                    ids.Add(item);
                }
                string bizcode = "scan-join";
                string tsql = $"select c.id, c.name ,c.lang as code from c where c.id in ({string.Join(",", ids.Select(x => $"'{x}'"))})";
                List<IdNameCode> idNameCodes = new List<IdNameCode>();
                await foreach (var item in _azureCosmos.GetCosmosClient().GetContainer(Constant.TEAMModelOS, Constant.Teacher)
                    .GetItemQueryIterator<IdNameCode>(queryText: tsql, requestOptions: new QueryRequestOptions { PartitionKey = new PartitionKey("Base") }))
                {
                    idNameCodes.Add(item);
                }
                _coreAPIHttpService.PushNotify(idNameCodes, $"{bizcode}_school", Constant.NotifyType_IES5_Management,
                          new Dictionary<string, object> { { "tmdname", teacher.name }, { "schoolName", schoolInfo.name }, { "schoolId", $"{school}" }, { "tmdid", teacher.id } }, _option.Location, _configuration, _dingDing, _environment.ContentRootPath);
            }
            catch (Exception ae)
            {
                await _dingDing.SendBotMsg($"HiTA扫码加入学校失败！{ae.Message},{ae.StackTrace}", GroupNames.成都开发測試群組);
            }
            return (200, "ok", new { schoolTeacher.roles, schoolTeacher.status, school = $"{school}", schoolInfo.name, schoolInfo.picture });
        }


        /// <summary>
        /// 根据年级获取入学年
        /// </summary>
        /// <param name="semesterList"></param>
        /// <returns></returns>
        public static (List<KeyValuePair<int, int>> gradeYear, HashSet<int> years) GetYears(School school, string periodId, IEnumerable<int> grades,long timestamp=0, string time = null) {
            var date = DateTimeOffset.UtcNow;
            //2001-09-09 09:46:40

            bool hasData = false;
            if (timestamp > 1000000000)
            {
                //毫秒级
                if (timestamp > 1000000000000)
                {
                    date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);
                    hasData = true;
                }
                //秒级
                else
                {
                    date = DateTimeOffset.FromUnixTimeSeconds(timestamp);
                    hasData =true;
                }
            }
            if (hasData==false)
            {
                if (!string.IsNullOrWhiteSpace(time))
                {

                    if (DateTimeOffset.TryParse(time, out date))
                    {
                        if (date.ToUnixTimeMilliseconds()<1514736000000)
                        {
                            date = DateTimeOffset.UtcNow;
                        }
                    }
                    else
                    {
                        date = DateTimeOffset.UtcNow;
                    }
                }
                else
                {
                    date = DateTimeOffset.UtcNow;
                }
            }


            //年级算法
            var period = school.period.Find(x => x.id.Equals(periodId));
          

            int Day = date.Day;
            int Month = date.Month;
            int Year = date.Year;
            int start = int.Parse($"{Year}0901");
            var se = period.semesters.Find(x => x.start == 1);
            if (se == null)
            {
                se = period.semesters.First();
            }
            string sm = "09";
            string sd = "01";
            if (se != null)
            {
                sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                start = int.Parse($"{Year}{sm}{sd}");
            }
            int curr = int.Parse(date.ToString("yyyyMMdd"));
            //新学年开学时间大于当前时间，计算年级需要减1   20220901-20220408 > 0 则当前20220408是2021年入学的，
            //当前时间大于新学年开学时间，计算年级则不需要  20220901-20221203 < 1 则当前20221203是2022年入学的，
            //20230901-20230101 > 0 则当前20230101是2022年入学的，
            int dis = start - curr;
            List<int > years= new List<int>();
            List<KeyValuePair<int, int>> gradeYear = new List<KeyValuePair<int, int>>();
            foreach (int grade in grades) {
                int year = 0;
                if (dis > 0)
                {
                    year = Year - grade -1;
                }
                else {
                    year= Year - grade ;
                }
                years.Add(year);
                gradeYear.Add(new KeyValuePair<int, int>(grade,year ));
            }
            return (gradeYear,years.ToHashSet());
        }

        /// <summary>
        /// 根据年份获取年级,只返回time 或当前时间以前入学的学生年级。
        /// </summary>
        /// <param name="semesterList"></param>
        /// <returns></returns>
        public static (List<KeyValuePair<int, string>> yearGrade,HashSet<string> grades) GetGrades(School school,string periodId , IEnumerable<int> years,long timestamp = 0,string time =null) {
            
            var date = DateTimeOffset.UtcNow;
            //2001-09-09 09:46:40

            bool hasData = false;
            if (timestamp > 1000000000)
            {
                //毫秒级
                if (timestamp > 1000000000000)
                {
                    date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);
                    hasData = true;
                }
                //秒级
                else
                {
                    date = DateTimeOffset.FromUnixTimeSeconds(timestamp);
                    hasData =true;
                }
            }
            if (hasData==false)
            {
                if (!string.IsNullOrWhiteSpace(time))
                {

                    if (DateTimeOffset.TryParse(time, out date))
                    {
                        if (date.ToUnixTimeMilliseconds()<1514736000000)
                        {
                            date = DateTimeOffset.UtcNow;
                        }
                    }
                    else
                    {
                        date = DateTimeOffset.UtcNow;
                    }
                }
                else
                {
                    date = DateTimeOffset.UtcNow;
                }
            }

            //年级算法
            var period = school.period.Find(x => x.id.Equals(periodId));
            int? Count = period?.grades?.Count;
            List<KeyValuePair<int, string>> yearGrades = new List<KeyValuePair<int, string>>();
            if (Count.HasValue)
            {
                int Day = date.Day;
                int Month = date.Month;
                int Year = date.Year;
                int start = int.Parse($"{Year}0901");
                var se = period.semesters.Find(x => x.start == 1);
                if (se == null)
                {
                    se = period.semesters.First();
                }
                string sm = "09";
                string sd = "01";
                if (se != null)
                {
                    sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                    sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                    start = int.Parse($"{Year}{sm}{sd}");
                }
                int curr = int.Parse(date.ToString("yyyyMMdd"));
                //新学年开学时间大于当前时间，计算年级需要减1   20220901-20220408 > 0 则当前20220408是2021年入学的，
                //当前时间大于新学年开学时间，计算年级则不需要  20220901-20221203 < 1 则当前20221203是2022年入学的，
                //20230901-20230101 > 0 则当前20230101是2022年入学的，
                int dis = start - curr;
                foreach (int year in years)
                {
                    if (int.Parse($"{year}{sm}{sd}") < curr) {
                        int grade;
                        if (dis > 0)
                        {
                            grade = Math.Abs((Year - year - 1)) % Count.Value;
                        }
                        else
                        {
                            grade = Math.Abs((Year - year)) % Count.Value;
                        }
                        yearGrades.Add(new KeyValuePair<int, string>(year, $"{grade}"));
                    }
                }
            }
            return (yearGrades, yearGrades.Select(z=>z.Value).ToHashSet());
        }

        public static (Semester currSemester, int studyYear, DateTimeOffset date, DateTimeOffset nextSemester) GetSemesterNew(Period period, long timestamp = 0, string time = null)
        {
            //string time = "2023/05-11";
            DateTimeOffset date = DateTimeOffset.Now;
            bool hasData = false;
            if (timestamp > 1000000000)
            {
                //毫秒级
                if (timestamp > 1000000000000)
                {
                    date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);
                    hasData = true;
                }
                //秒级
                else
                {
                    date = DateTimeOffset.FromUnixTimeSeconds(timestamp);
                    hasData =true;
                }
            }
            if (hasData==false)
            {
                if (!string.IsNullOrWhiteSpace(time))
                {

                    if (DateTimeOffset.TryParse(time, out date))
                    {
                        if (date.ToUnixTimeMilliseconds()<1514736000000) {
                            date = DateTimeOffset.UtcNow;
                        }
                    }
                    else
                    {
                        date = DateTimeOffset.UtcNow;
                    }
                }
                else
                {
                    date = DateTimeOffset.UtcNow;
                }
            }

            int Day = date.Day;
            int Month = date.Month;
            int Year = date.Year;
            string sm = "09";
            string sd = "01";
            int start = int.Parse($"{Year}{sm}{sd}");
            var se = period.semesters.Find(x => x.start == 1);
            if (se == null)
            {
                se = period.semesters.First();
            }

            if (se != null)
            {
                sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                start = int.Parse($"{Year}{sm}{sd}");
            }
            int curr = int.Parse(date.ToString("yyyyMMdd"));
            //新学年开学时间大于当前时间，计算年级需要减1   20220901-20220408 > 0 则当前20220408是2021年入学的，
            //当前时间大于新学年开学时间，计算年级则不需要  20220901-20221203 < 0 则当前20221203是2022年入学的，
            //20230901-20230101 > 0 则当前20230101是2022年入学的，
            int dis = start - curr;
            //学年
            int studyYear = date.Year;
            if (dis > 0)
            {
                studyYear = Year - 1;
            }
            else
            {
                studyYear = Year;
            }
            Semester semester = null;
            //当前学期的下一个学期,默认加180天
            DateTimeOffset nextSemester = date.AddDays(180);
            var sortSemesters = SortSemester(period.semesters);
            int len = sortSemesters.Count;
            for (int i = 0; i < len; i++)
            {
                int next = i + 1;
                if (next>= len)
                {
                    semester = sortSemesters[i];
                    nextSemester = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[0].month}/{sortSemesters[0].day}");
                    break;
                }
                else
                {

                    var fdate = DateTimeOffset.Parse($"{studyYear}/{sortSemesters[i].month}/{sortSemesters[i].day}");
                    long lf = fdate.ToUnixTimeSeconds();
                    var ndate = DateTimeOffset.Parse($"{studyYear}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                    long ln = ndate.ToUnixTimeSeconds();
                    //代表有跨年
                    if (lf > ln)
                    {
                        ndate = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                        ln = ndate.ToUnixTimeSeconds();
                    }
                    var cdate = DateTimeOffset.Parse($"{Year}/{Month}/{Day}");
                    long lc = cdate.ToUnixTimeSeconds();
                    if (lc >= lf && lc < ln)
                    {
                        semester = sortSemesters[i];
                        nextSemester = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                        //nextSemester = sortSemesters[next];
                        break;
                    }
                    //if (sortSemesters[i].month <=Month && sortSemesters[i].day >= Day && sortSemesters[next].month < Month && sortSemesters[next].day < Day) 
                    //{

                    //    semester = sortSemesters[i];
                    //    nextSemester = DateTimeOffset.Parse($"{studyYear}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                    //    break; 
                    //}
                }
            }
            return (semester, studyYear, date, nextSemester);
        }


        /// <summary>
        /// 根据指定时间或者当前时间获取学期信息
        /// </summary>
        /// <param name="semesterList"></param>
        /// <returns></returns>
        public static (Semester currSemester,  int studyYear, DateTimeOffset currSemesterDate, DateTimeOffset date, DateTimeOffset nextSemester) GetSemester(  Period period, long timestamp = 0,  string time =null) {
            //string time = "2023/05-11";
            DateTimeOffset date = default;
            bool  hasData=false;
            if (timestamp > 1000000000) {
                //毫秒级
                if (timestamp > 1000000000000)
                {
                    date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);
                    hasData=true;
                }
                //秒级
                else {
                    date = DateTimeOffset.FromUnixTimeSeconds(timestamp);
                    hasData=true;
                }
            }
            if (hasData==false) {
                if (!string.IsNullOrWhiteSpace(time))
                {

                    if (DateTimeOffset.TryParse(time, out date))
                    {
                        if (date.ToUnixTimeMilliseconds()<1514736000000)
                        {
                            date = DateTimeOffset.UtcNow;
                        }
                    }
                    else
                    {
                        date = DateTimeOffset.UtcNow;
                    }
                }
                else
                {
                    date = DateTimeOffset.UtcNow;
                }
            }
           
            //年级算法
            //var period = school.period.Find(x => x.id.Equals(periodId));
            List<KeyValuePair<int, string>> yearGrades = new List<KeyValuePair<int, string>>();
            int Day = date.Day;
            int Month = date.Month;
            int Year = date.Year;
            string sm = "09";
            string sd = "01";
            int start = int.Parse($"{Year}{sm}{sd}");
            var se = period.semesters.Find(x => x.start == 1);
            if (se == null)
            {
                se = period.semesters.First();
            }
           
            if (se != null)
            {
                sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                start = int.Parse($"{Year}{sm}{sd}");
            }
            int curr = int.Parse(date.ToString("yyyyMMdd"));
            //新学年开学时间大于当前时间，计算年级需要减1   20220901-20220408 > 0 则当前20220408是2021年入学的，
            //当前时间大于新学年开学时间，计算年级则不需要  20220901-20221203 < 0 则当前20221203是2022年入学的，
            //20230901-20230101 > 0 则当前20230101是2022年入学的，
            int dis = start - curr;
            //学年
            int studyYear= date.Year;
            if (dis > 0)
            {
                studyYear = Year - 1;
            }
            else
            {
                studyYear = Year;
            }
            Semester semester= null;
            //当前学期的下一个学期,默认加180天
            DateTimeOffset nextSemester = date.AddDays(180);
            DateTimeOffset currSemesterDate = default;
            var sortSemesters= SortSemester(period.semesters);
            int len = sortSemesters.Count;
            int currSemesterYear = studyYear;
            for (int i = 0; i < len; i++) {
                int next=  i + 1;
                if (next>= len)
                {
                    semester = sortSemesters[i];
                   
                    nextSemester = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[0].month}/{sortSemesters[0].day}");
                    currSemesterDate=DateTimeOffset.Parse($"{currSemesterYear}/{semester.month}/{semester.day}");
                    if (currSemesterDate.Subtract(nextSemester).TotalDays>0) {
                        currSemesterDate=DateTimeOffset.Parse($"{currSemesterYear-1}/{semester.month}/{semester.day}");
                    }
                    break;
                }
                else {

                    var fdate= DateTimeOffset.Parse($"{studyYear}/{sortSemesters[i].month}/{sortSemesters[i].day}");
                    long lf = fdate.ToUnixTimeSeconds();
                    var ndate = DateTimeOffset.Parse($"{studyYear}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                    long ln = ndate.ToUnixTimeSeconds();
                    //代表有跨年
                    if (lf > ln) {
                        currSemesterYear=studyYear+1;
                        ndate = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                        ln = ndate.ToUnixTimeSeconds();
                    }
                    var cdate = DateTimeOffset.Parse($"{Year}/{Month}/{Day}");
                    long lc = cdate.ToUnixTimeSeconds();
                    if (lc >= lf && lc < ln) {
                        semester = sortSemesters[i];
                        nextSemester = DateTimeOffset.Parse($"{studyYear+1}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                        currSemesterDate=DateTimeOffset.Parse($"{currSemesterYear}/{semester.month}/{semester.day}");
                        if (currSemesterDate.Subtract(nextSemester).TotalDays>0)
                        {
                            currSemesterDate=DateTimeOffset.Parse($"{currSemesterYear-1}/{semester.month}/{semester.day}");
                        }
                        break;
                    }
                    //if (sortSemesters[i].month <=Month && sortSemesters[i].day >= Day && sortSemesters[next].month < Month && sortSemesters[next].day < Day) 
                    //{

                    //    semester = sortSemesters[i];
                    //    nextSemester = DateTimeOffset.Parse($"{studyYear}/{sortSemesters[next].month}/{sortSemesters[next].day}");
                    //    break; 
                    //}
                }
            }
            return (semester,studyYear, currSemesterDate, date, nextSemester); 
        }

        /// <summary>
        /// 处理学期排序
        /// </summary>
        /// <param name="semesterList"></param>
        /// <returns></returns>
        public static List<Semester> SortSemester(List<Semester> semesterList)
        {
            int Year = DateTimeOffset.UtcNow.Year;
            List<KeyValuePair<int, Semester>> pairs = new List<KeyValuePair<int, Semester>>();
            semesterList.ForEach(se => {
                string sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                string sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                int order = int.Parse($"{Year}{sm}{sd}");
                pairs.Add(new KeyValuePair<int, Semester>(order, se));
            });
            var orderPairs = pairs.OrderBy(z => z.Key);
            semesterList = orderPairs.Select(z => z.Value).ToList();
            int startIndex = semesterList.FindIndex(z => z.start == 1);
            if (startIndex == -1)
            {
                //未设置学期的情况默认9月份开始的。
                startIndex = semesterList.FindIndex(z => z.month == 9);
                //如果还未找到，就以排序结果为准
                if (startIndex == -1)
                {
                    startIndex = 0;
                }
            }
            if (startIndex > 0)
            {
                List<Semester> before = semesterList.Take(startIndex).ToList();
                List<Semester> after = semesterList.Skip(startIndex).ToList();
                semesterList = new List<Semester>();
                semesterList.AddRange(after);
                semesterList.AddRange(before);
                return semesterList;
            }
            else
            {
                return semesterList;
            }
        }

        /// <summary>
        /// 获取指定学年，指定学期的开学时间。
        /// </summary>
        /// <param name="semesterList"></param>
        /// <returns></returns>
        public static string GetOpensByStudyYearAndSemester(List<Semester> semesterList,int year ,string semesterId)
        {
            int Year = DateTimeOffset.UtcNow.Year;
            List<KeyValuePair<int, Semester>> pairs = new List<KeyValuePair<int, Semester>>();
            semesterList.ForEach(se => {
                string sm = se.month >= 10 ? $"{se.month}" : $"0{se.month}";
                string sd = se.day >= 10 ? $"{se.day}" : $"0{se.day}";
                int order = int.Parse($"{Year}{sm}{sd}");
                pairs.Add(new KeyValuePair<int, Semester>(order, se));
            });
            var orderPairs = pairs.OrderBy(z => z.Key);
            semesterList = orderPairs.Select(z => z.Value).ToList();
            int startIndex = semesterList.FindIndex(z => z.start == 1);
            if (startIndex == -1)
            {
                //未设置学期的情况默认9月份开始的。
                startIndex = semesterList.FindIndex(z => z.month == 9);
                //如果还未找到，就以排序结果为准
                if (startIndex == -1)
                {
                    startIndex = 0;
                }
            }
            if (startIndex > 0)
            {
                List<Semester> before = semesterList.Take(startIndex).ToList();
                List<Semester> after = semesterList.Skip(startIndex).ToList();
                semesterList = new List<Semester>();
                semesterList.AddRange(after);
                semesterList.AddRange(before);
                 
            }
            string time = string.Empty;
            for (int i = 0; i<semesterList.Count; i++) {
                if (semesterList[i].id.Equals(semesterId)) {
                    if (i==0)
                    {
                        time=$"{year}-{semesterList[i].month}-{semesterList[i].day}";
                    }
                    else {
                        string sm1 = semesterList[i-1].month >= 10 ? $"{semesterList[i-1].month}" : $"0{semesterList[i-1].month}";
                        string sd1 = semesterList[i-1].day >= 10 ? $"{semesterList[i-1].day}" : $"0{semesterList[i - 1].day}";
                        int order1 = int.Parse($"{Year}{sm1}{sd1}");

                        string sm2 = semesterList[i].month >= 10 ? $"{semesterList[i].month}" : $"0{semesterList[i].month}";
                        string sd2 = semesterList[i].day >= 10 ? $"{semesterList[i].day}" : $"0{semesterList[i].day}";
                        int order2 = int.Parse($"{Year}{sm2}{sd2}");
                        if (order2<order1)
                        {
                            time=$"{(year+1)}-{semesterList[i].month}-{semesterList[i].day}";
                        }
                        else {
                            time=$"{year}-{semesterList[i].month}-{semesterList[i].day}";
                        }
                    }
                }
            }
            return time;
        }
        /// <summary>
        /// 校验
        /// </summary>
        /// <param name="courseTaskInsert"></param>
        public static ScheduleTaskDto CheckCourseTask(string scope, ScheduleTaskDto courseTaskInsert, string school,  List<GroupListDto> groupListDtos, List<Room> rooms,
            List<SchoolTeacher> schoolTeachers, List<Teacher> teachers)
        {
            if (scope.Equals("school", StringComparison.OrdinalIgnoreCase))
            {   
                //教师
                var schoolteachers = schoolTeachers.Where(z => z.id.Equals(courseTaskInsert.teacherId));
                if (!schoolteachers.Any())
                {
                    courseTaskInsert.invalidCode = 2;//教师不存在

                    return courseTaskInsert;
                }
                var invalidAssistants=  courseTaskInsert.assistants.Except(schoolTeachers.Select(x => x.id));
                if (invalidAssistants != null && invalidAssistants.Any())
                {
                    courseTaskInsert.invalidCode = 21;
                    courseTaskInsert.invalidMsg = $"{string.Join(",", invalidAssistants)}";
                    return courseTaskInsert;
                }
            }
            else
            {
                //教师
                var teachersbase = teachers.Where(z => z.id.Equals(courseTaskInsert.teacherId));
                if (!teachersbase.Any())
                {
                    courseTaskInsert.invalidCode = 2;//教师不存在
                    return courseTaskInsert;
                }
                var invalidAssistants = courseTaskInsert.assistants.Except(teachers.Select(x => x.id));
                if (invalidAssistants != null && invalidAssistants.Any())
                {
                    courseTaskInsert.invalidCode = 21;
                    courseTaskInsert.invalidMsg = $"{string.Join(",", invalidAssistants)}";
                    return courseTaskInsert;
                }
            }
          
            //名单
            var groupList = groupListDtos.Where(z => z.id.Equals(courseTaskInsert.groupId) && z.type.Equals(courseTaskInsert.type));
            if (!groupList.Any())
            {
                courseTaskInsert.invalidCode = 3;//名单不存在
                return courseTaskInsert;
            }
            else
            {
                if (scope.Equals("private", StringComparison.OrdinalIgnoreCase))
                {
                    if (!groupList.First().scope.Equals("private", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(school) && school.Equals(groupList.First().school))
                    {
                        courseTaskInsert.school = school;
                    }
                }
                else
                {
                    courseTaskInsert.school = school;
                }
            }
            //教室
            if (!string.IsNullOrWhiteSpace(courseTaskInsert.roomId))
            {
                var room = rooms.Where(z => z.id.Equals(courseTaskInsert.roomId));
                if (!room.Any())
                {
                    courseTaskInsert.invalidCode = 4;//教室不存在
                    return courseTaskInsert;
                }
            }
             
            courseTaskInsert.invalidCode = 0;
            return courseTaskInsert;
        }

        /// <summary>
        /// 校验
        /// </summary>
        /// <param name="courseTaskInsert"></param>
        public static CourseTaskChanged CheckCourseTaskInsertOrChanged(string grant_type,  string scope , CourseTaskChanged courseTaskInsert,string school,Period period, List<CourseBase> courseBases, List<GroupListDto> groupListDtos, List<Room> rooms,
            List<SchoolTeacher> schoolTeachers,List<Teacher> teachers)
        {
            if (scope.Equals("school", StringComparison.OrdinalIgnoreCase))
            {  //学年
                if (courseTaskInsert.year < 2000)
                {
                    courseTaskInsert.invalidCode = 17;//学年应大于2000
                    return courseTaskInsert;
                }
                //学期
                var semester = period.semesters.Where(z => z.id.Equals(courseTaskInsert.semesterId));
                if (!semester.Any())
                {
                    courseTaskInsert.invalidCode = 16;//学期不存在
                    return courseTaskInsert;
                }
                //教师
                var schoolteachers = schoolTeachers.Where(z => z.id.Equals(courseTaskInsert.teacherId));
                if (!schoolteachers.Any())
                {
                    courseTaskInsert.invalidCode = 2;//教师不存在
                    return courseTaskInsert;
                }
            }
            else {
                //教师
                var teachersbase = teachers.Where(z => z.id.Equals(courseTaskInsert.teacherId));
                if (!teachersbase.Any())
                {
                    courseTaskInsert.invalidCode = 2;//教师不存在
                    return courseTaskInsert;
                }
            }
            //课程
            var courseBase = courseBases.Where(z => z.id.Equals(courseTaskInsert.courseId));
            if (!courseBase.Any())
            {
                courseTaskInsert.invalidCode = 1;//课程不存在
                return courseTaskInsert;
            }
            //名单
            var groupList = groupListDtos.Where(z => z.id.Equals(courseTaskInsert.groupId) && z.type.Equals(courseTaskInsert.type));
            if (!groupList.Any())
            {
                courseTaskInsert.invalidCode = 3;//名单不存在
                return courseTaskInsert;
            }
            else {
                if (scope.Equals("private", StringComparison.OrdinalIgnoreCase))
                {
                    if (!groupList.First().scope.Equals("private", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(school) && school.Equals(groupList.First().school))
                    {
                        courseTaskInsert.school = school;
                    }
                }
                else {
                    courseTaskInsert.school = school;
                }
            }
            //教室
            if (!string.IsNullOrWhiteSpace(courseTaskInsert.roomId))
            {
                var room = rooms.Where(z => z.id.Equals(courseTaskInsert.roomId));
                if (!room.Any())
                {
                    courseTaskInsert.invalidCode = 4;//教室不存在
                    return courseTaskInsert;
                }
            }
            if (grant_type.Equals("change-scheduleTask", StringComparison.OrdinalIgnoreCase)) {
                if (!string.IsNullOrWhiteSpace(courseTaskInsert.teacherIdChanged) || (!string.IsNullOrWhiteSpace(courseTaskInsert.groupIdChanged) && !string.IsNullOrWhiteSpace(courseTaskInsert.typeChanged)))
                {
                    if (!string.IsNullOrWhiteSpace(courseTaskInsert.teacherIdChanged)) {
                        if (scope.Equals("school", StringComparison.OrdinalIgnoreCase))
                        {
                            //教师
                            var schoolteachers = schoolTeachers.Where(z => z.id.Equals(courseTaskInsert.teacherIdChanged));
                            if (!schoolteachers.Any())
                            {
                                courseTaskInsert.invalidCode = 19;//教师不存在
                                return courseTaskInsert;
                            }
                        }
                        else {
                            //教师
                            var teachersbase = teachers.Where(z => z.id.Equals(courseTaskInsert.teacherIdChanged));
                            if (!teachersbase.Any())
                            {
                                courseTaskInsert.invalidCode = 19;//教师不存在
                                return courseTaskInsert;
                            }
                        }
                    }
                    if (!string.IsNullOrWhiteSpace(courseTaskInsert.groupIdChanged) && !string.IsNullOrWhiteSpace(courseTaskInsert.typeChanged)) {
                        //名单
                        var groupListChanged = groupListDtos.Where(z => z.id.Equals(courseTaskInsert.groupIdChanged) && z.type.Equals(courseTaskInsert.typeChanged));
                        if (!groupListChanged.Any())
                        {
                            courseTaskInsert.invalidCode = 18;//名单不存在
                            return courseTaskInsert;
                        }
                        else
                        {
                            if (scope.Equals("private", StringComparison.OrdinalIgnoreCase))
                            {
                                if (!groupListChanged.First().scope.Equals("private", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(school) && school.Equals(groupList.First().school))
                                {
                                    courseTaskInsert.school = school;
                                }
                            }
                            else
                            {
                                courseTaskInsert.school = school;
                            }
                        }
                    }
                }
                else {
                    courseTaskInsert.invalidCode = 17;
                }
            }
            courseTaskInsert.invalidCode = 0;
            return courseTaskInsert;
        }


        public static async Task<(List<Class> school_classes, List<Class> graduate_classes)> DoGraduateClasses(HttpTrigger _httpTrigger, AzureCosmosFactory _azureCosmos, List<string> periodIds, School school_base, Option _option,DingDing _dingDing, int waite = 0) {
            List<Class> school_classes = new List<Class>();
            List<Class> graduate_classes = new List<Class>();
            try
            {
                var client = _azureCosmos.GetCosmosClient();
                //取得班级
             
                int nowYear = DateTimeOffset.UtcNow.Year;
                int nowMonth = DateTimeOffset.UtcNow.Month;
                int nowDay = DateTimeOffset.UtcNow.Day;
              
                //因为修改年级，而导致取消的
                List<Class> cancel_graduate_classes = new List<Class>();
                string sql = $"SELECT value c  FROM c where  (c.graduate = 0 or  IS_DEFINED(c.graduate) = false) ";
                if (periodIds.IsNotEmpty())
                {
                    sql = $"SELECT value c  FROM c where c.periodId in ({string.Join(",", periodIds.Select(x => $"'{x}'"))}) ";
                }
                await foreach (var item in client.GetContainer(Constant.TEAMModelOS, "School").GetItemQueryIterator<Class>
                     //(queryText: $"SELECT value c  FROM c where (c.graduate = 0 or  IS_DEFINED(c.graduate) = false)",
                     (queryText: sql,
                    requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey($"Class-{school_base.id}") }))
                {

                    bool isgraduate = false;
                    if (!string.IsNullOrWhiteSpace(item.periodId))
                    {
                        var period = school_base.period.Find(x => x.id.Equals(item.periodId));
                        if (period != null)
                        {
                            var gradeCount = period.grades.Count();
                            //2022-2016=6（待判断月份日期是否是毕业）  2022-2017=5（未毕业）
                            if (nowYear - item.year > gradeCount)
                            {
                                isgraduate = true;
                            }
                            else if (nowYear - item.year == gradeCount)
                            {
                                var semester = period.semesters.Find(x => x.start == 1);
                                if (semester != null)
                                {
                                    if (nowMonth > semester.month)
                                    {
                                        isgraduate = true;
                                    }
                                    else if (nowMonth == semester.month)
                                    {
                                        if (nowDay >= semester.day)
                                        {
                                            isgraduate = true;
                                        }
                                        else
                                        {
                                        }
                                    }
                                    else { isgraduate = false; }
                                }
                            }
                            else
                            {
                                isgraduate = false;
                            }
                        }
                    }
                    if (isgraduate)
                    {
                        graduate_classes.Add(item);
                    }
                    else
                    {
                        if (item.graduate == 1)
                        {
                            item.graduate = 0;
                            cancel_graduate_classes.Add(item);
                        }
                        school_classes.Add(item);
                    }
                }
                if (graduate_classes.Any() || cancel_graduate_classes.Any())
                {
                    if (waite == 0)
                    {
                        _ = _httpTrigger.RequestHttpTrigger(new { graduate_classes = graduate_classes, cancel_graduate_classes = cancel_graduate_classes, schoolId = $"{school_base.id}" }, _option.Location, "graduate-change");
                    }
                    else
                    {
                        await _httpTrigger.RequestHttpTrigger(new { graduate_classes = graduate_classes, cancel_graduate_classes = cancel_graduate_classes, schoolId = $"{school_base.id}" }, _option.Location, "graduate-change");
                    }
                }
            } catch (Exception ex) {
               await _dingDing.SendBotMsg($"{_option.Location},{ex.Message}\n{ex.StackTrace}", GroupNames.醍摩豆服務運維群組);
            }
            return (school_classes,graduate_classes);
        }


        public static async Task<object> DoScsApiSchool(HttpTrigger _httpTrigger,Dictionary<string,object> dict, Option _option, List<IdNameCode> ignore,
            string areaId,string city,string dist, AzureStorageFactory _azureStorage ,DingDing _dingDing, IWebHostEnvironment _environment
            )
        {
            List<ScSchool> tbschools = null;
            List<ScSchool> matchSchools = null;
            List<ScSchool> schools = null;
            List<ScSchool> saveschools = null;
            var table = _azureStorage.GetCloudTableClient().GetTableReference("ScYxpt");
            // 5.3.1.18根据机构ID、项目ID、子项目ID返回学校列表
            (  int status, string json) = await _httpTrigger.RequestHttpTrigger(dict, _option.Location, "GetSchoolList");
            if (status == 200)
            {
                schools = json.ToObject<List<ScSchool>>(new JsonSerializerOptions { PropertyNameCaseInsensitive = false });
                if (ignore.IsNotEmpty())
                {
                    matchSchools = schools.FindAll(x => ignore.Select(y => y.name).Contains(x.schoolname));
                    if (matchSchools.IsNotEmpty())
                    {
                        if (matchSchools.Count != ignore.Count)
                        {
                            var matched = matchSchools.Select(x => x.schoolname);
                            var unmatch = ignore.Select(y => y.name).Except(matched);
                            List<string> scschoolUnmatch = schools.Select(y => y.schoolname).Except(matched).ToList();
                            if (scschoolUnmatch.IsNotEmpty())
                            {
                                return new { matched, unmatch, scschoolUnmatch };
                            }
                        }
                        else
                        {
                            matchSchools.ForEach(x => {
                                var exschool = ignore.Find(y => y.name.Equals(x.schoolname));
                                if (exschool != null)
                                {
                                    x.schoolCode = exschool.id;
                                    x.areaId = $"{areaId}";
                                    x.city = $"{city}";
                                    x.dist = $"{dist}";
                                }
                            });
                        }
                    }
                    else
                    {
                        return new { unmatch = ignore, schools };
                    }
                }
                //数据校验
                tbschools = await table.FindListByDict<ScSchool>(new Dictionary<string, object>() { { "PartitionKey", "ScSchool" } });
                if (tbschools.IsNotEmpty())
                {

                    var a = tbschools.Select(y => $"{y.RowKey}").ToList();
                    saveschools = schools.Where(x => !a.Exists(z => z.Equals($"{x.schoolid}"))).ToList();
                    List<SchoolData> schoolDatas = new List<SchoolData>();
                    saveschools.ForEach(x =>
                    {
                        x.RowKey = $"{x.schoolid}";
                        x.PartitionKey = "ScSchool";
                        x.areaId = $"{areaId}";
                        x.city = $"{city}";
                        x.dist = $"{dist}";
                        if (string.IsNullOrEmpty(x.schoolCode))
                        {
                            if (string.IsNullOrEmpty(x.schoolCode))
                            {
                                schoolDatas.Add(new SchoolData { uid = $"{x.schoolid}", province = "四川省", city = $"{city}", name = x.schoolname });
                            }
                           
                        }
                    });
                    schoolDatas = await SchoolService.GenerateSchoolCode(schoolDatas, _dingDing, _environment);
                    saveschools.ForEach(x => {

                        var schoolData = schoolDatas.Find(y => y.uid.Equals($"{x.schoolid}"));
                        if (schoolData != null && !string.IsNullOrEmpty(schoolData.id))
                        {
                            x.schoolCode = schoolData.id;
                            x.areaId = $"{areaId}";
                            x.city = $"{city}";
                            x.dist = $"{dist}";
                        }
                    });
                    saveschools.RemoveAll(x => string.IsNullOrEmpty(x.schoolCode));
                    saveschools.RemoveAll(x => tbschools.FindAll(z => !string.IsNullOrEmpty(z.schoolCode)).Exists(y => y.schoolCode.Equals(x.schoolCode)));
                    saveschools = await table.SaveAll(saveschools);
                }
                else
                {
                    List<SchoolData> schoolDatas = new List<SchoolData>();
                    schools.ForEach(x =>
                    {
                        x.RowKey = $"{x.schoolid}";
                        x.PartitionKey = "ScSchool";
                        x.areaId = $"{areaId}";
                        x.city = $"{city}";
                        x.dist = $"{dist}";
                        var a = ignore.Find(z => z.name.Equals(x.schoolname));
                        if (a != null)
                        {
                            x.schoolCode = a.id;
                        }
                        else
                        {
                            if (string.IsNullOrEmpty(x.schoolCode))
                            {
                                schoolDatas.Add(new SchoolData { uid = $"{x.schoolid}", province = "四川省", city = $"{city}", name = x.schoolname });
                            }
                        }
                    });
                    schoolDatas = await SchoolService.GenerateSchoolCode(schoolDatas, _dingDing, _environment);
                    schools.ForEach(x => {
                        var schoolData = schoolDatas.Find(y => y.uid.Equals($"{x.schoolid}"));
                        if (schoolData != null && !string.IsNullOrEmpty(schoolData.id))
                        {
                            x.schoolCode = schoolData.id;
                            x.areaId = $"{areaId}";
                            x.city = $"{city}";
                            x.dist = $"{dist}";
                        }
                    });

                    schools.RemoveAll(x => string.IsNullOrEmpty(x.schoolCode));
                    saveschools = await table.SaveOrUpdateAll(schools);
                }
            }
            return null;
        }

        public static async Task<List<SchoolData>> GenerateSchoolCode(List<SchoolData> schools, DingDing _dingDing, IWebHostEnvironment _environment)
        {
            string path = $"{_environment.ContentRootPath}/JsonFile/Core/region.json";
            //var schools = jsonstr.ToObject<JsonElement>().GetProperty("schools").ToObject<List<SchoolData>>();
            schools = schools.Where((x, i) => schools.FindIndex(n => n.name.Equals(x.name)) == i).ToList();
            StreamReader streamReader = new StreamReader(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8);
            StringBuilder stringBuilder = new StringBuilder();
            string text;
            while ((text = streamReader.ReadLine()) != null)
            {
                stringBuilder.Append(text.ToString());
            }
            streamReader.Close();
            string input = stringBuilder.ToString();
            List<Region> region = input.ToObject<List<Region>>();
            try
            {
                schools.ForEach(x =>
                {
                    x.province = ChineseConverter.Convert(x.province, ChineseConversionDirection.TraditionalToSimplified);
                    if (String.IsNullOrEmpty(x.city))
                    {
                        x.city = x.province;
                    }
                    else
                    {
                        x.city = ChineseConverter.Convert(x.city, ChineseConversionDirection.TraditionalToSimplified);
                    }

                    x.name = ChineseConverter.Convert(x.name, ChineseConversionDirection.TraditionalToSimplified);
                    comeRemoveStr.ForEach(c => { x.province = x.province.Replace(c, ""); });
                    prvcRemoveStr.ForEach(c => { x.province = x.province.Replace(c, ""); });
                    var province = region.Find(r => r.name.Contains(x.province));
                    string tmpprovince = x.province;
                    string tmpcity = x.city;
                    if (province != null)
                    {
                        x.province = province.name;
                        comeRemoveStr.ForEach(c => { x.city = x.city.Replace(c, ""); });
                        cityRemoveStr.ForEach(c => { x.city = x.city.Replace(c, ""); });
                        nationRemoveStr.ForEach(c => { x.city = x.city.Replace(c, ""); });
                        tmpcity = x.city;
                        var city = province.children.Find(r => r.name.Contains(x.city));

                        if (city == null)
                        {
                            city = province.children.Find(r => r.name.Contains(x.city));
                            if (city == null)
                            {
                                city = province.children.SelectMany(x => x.children).ToList().Find(r => r.name.Contains(x.city));
                            }
                        }
                        if (city != null)
                        {
                            x.city = city.name;
                        }
                    }

                    string name = x.name;
                    //去除冗余的学校信息，只保留地名和校名关键信息
                    schemoveStr.ForEach(str =>
                    {
                        name = name.Replace(str, "");
                    });
                    string[] names = name.Split("(");
                    if (names.Length > 1)
                    {
                        name = $"{names[0]}";
                        for (int index = 1; index < names.Length; index++)
                        {
                            name = $"{name}{names[index].Substring(0, 1)}";
                            var afnames = names[index].Split(")");
                            if (afnames.Length > 1)
                            {
                                for (int i = 1; i < afnames.Length; i++)
                                {
                                    name = $"{name}{afnames[i]}";
                                }
                            }
                        }
                    }
                    names = name.Split("（");
                    if (names.Length > 1)
                    {
                        name = $"{names[0]}";
                        for (int index = 1; index < names.Length; index++)
                        {
                            name = $"{name}{names[index].Substring(0, 1)}";
                            var afnames = names[index].Split("）");
                            if (afnames.Length > 1)
                            {
                                for (int i = 1; i < afnames.Length; i++)
                                {
                                    name = $"{name}{afnames[i]}";
                                }
                            }
                        }
                    }
                    name = Regex.Replace(name, "[ \\[ \\] \\^ \\-|（）【】/' {}_*×――(^)$%~!@#$…&%￥—+=<>《》!！??？:：•`·、。，；,.;\"‘’“”-]", " ");
                    //检查是否有英文
                    if (Regex.Matches(name, "[a-zA-Z]").Count > 0)
                    {
                        var array = Regex.Split(name, "\\s+", RegexOptions.IgnoreCase);
                        StringBuilder tmpname = new StringBuilder();
                        if (array.Length > 1)
                        {
                            foreach (var item in array)
                            {
                                var arr = item.Select(x => $"{x}");
                                int index = 0;
                                foreach (var stra in arr)
                                {
                                    if (Regex.Matches(stra, "[a-zA-Z]").Count > 0)
                                    {
                                        if (index == 1|| index == 0)
                                        {
                                            tmpname.Append(stra);
                                        }
                                        else
                                        {

                                        }
                                    }
                                    else
                                    {
                                        tmpname.Append(stra);
                                    }
                                    index++;
                                }
                            }
                        }
                        else
                        {
                            var arr = name.Select(x => $"{x}");
                            int index = 0;
                            foreach (var stra in arr)
                            {
                                if (Regex.Matches(stra, "[A-Z]").Count > 0)
                                {
                                    tmpname.Append(stra);
                                }
                                else if (Regex.Matches(stra, "[a-z]").Count > 0)
                                {
                                }
                                else
                                {
                                    tmpname.Append(stra);
                                }
                                index++;
                            }

                        }
                        name = tmpname.ToString();
                    }
                    name = Regex.Replace(name, @"\s", "");
                    name = name.Replace("\\", "");
                    if (name.Length > 6)
                    {
                        //新区，高新，产业等非新政单位
                        areaRemoveStr.ForEach(str =>
                        {
                            name = name.Replace(str.Key, str.Value);
                        });
                        //去除冗余的学校信息，只保留地名和校名关键信息
                        schooRemoveStr.ForEach(str =>
                        {
                            name = name.Replace(str, "");
                        });

                        //替换民族信息词
                        if (name.Length > 6)
                        {
                            nationRemoveStr.ForEach(str =>
                            {
                                name = name.Replace(str, "");
                            });
                        }
                        //替换学校信息的副词
                        if (name.Length > 6)
                        {
                            foreach (var str in schooReplaceStr)
                            {
                                if (name.Length <= 6)
                                {
                                    break;
                                }
                                name = name.Replace(str.Key, str.Value);

                            }
                        }
                        //替换省简称信息词
                        string tmpname = name;
                        if (name.Length > 6)
                        {
                            proReplaceStr.ForEach(str =>
                            {
                                name = name.Replace(str.Key, str.Value);
                            });
                            //如果替换后仍然大于6位，则取消，直接替换省份完整的词
                            if (name.Length > 6)
                            {
                                name = tmpname.Replace(tmpprovince, "");
                            }
                        }
                        //替换城市信息词
                        if (name.Length > 6)
                        {
                            name = name.Replace(tmpcity, "");
                        }

                    }
                    int len = name.Length;
                    if (len > 6)
                    {
                        foreach (var str in afterSchoolRm)
                        {
                            if (name.Length <= 6)
                            {
                                break;
                            }
                            name = name.Replace(str, "");
                        }
                    }

                    len = name.Length;
                    if (len >= 6)
                    {
                        name = $"{name.Substring(0, 1)}{name.Substring(len - 5, 3)}{name.Substring(len - 2, 2)}";
                    }
                    //if (len <= 7 && len > 6)
                    //{
                    //    name = name.Substring(len - 6);
                    //}
                    if (len <= 4)
                    {
                        name = $"{x.city.Substring(0, 2)}{name}";
                    }
                    if (len == 5)
                    {
                        name = $"{x.city.Substring(0, 1)}{name}";
                    }
                    string code = ToFirstPinYin(name);
                    x.aname = name;
                    x.id = code;

                });
            }
            catch (Exception ex)
            {
                await _dingDing.SendBotMsg($"{ex.Message}\n{ex.StackTrace}\n", GroupNames.醍摩豆服務運維群組);
            }
            string a_z = "abcdefghijklmnopqrstuvwxyz";
            var data = schools.GroupBy(x => x.id).Select(x => new { key = x.Key, more = x.ToList().Count > 2, count = x.ToList().Count, list = x.ToList() }).ToList();
            data.ForEach(x =>
            {
                if (x.count > 1)
                {
                    var first = x.list.First();
                    var same = x.list.Skip(1).Take(x.count - 1).ToList();
                    var fs = first.aname.Select(x => x).ToArray();
                    same.ForEach(z =>
                    {
                        var sp = z.aname.Select(x => x).ToArray();
                        int len = sp.Length;
                        if (sp.Length >= fs.Length)
                        {
                            len = fs.Count();
                        }
                        for (int index = 0; index < len; index++)
                        {
                            if (!$"{sp[index]}".Equals($"{fs[index]}"))
                            {
                                short st = ChineseChar.GetStrokeNumber(sp[index]);
                                if (st > 0)
                                {
                                    var ins = st % 27;
                                    var insch = a_z[ins];
                                    if (z.aname.EndsWith($"{insch}"))
                                    {
                                        ins = (st + 1) % 27;
                                        insch = a_z[ins];
                                    }
                                    z.id = z.id.Insert(index, $"{insch}").Remove(index + 1, 1);
                                    break;
                                }
                            }
                        }
                    });
                }
            });
            var dataz = data.SelectMany(y=>y.list).GroupBy(x => x.id).Select(x => new { key = x.Key, more = x.ToList().Count > 2, count = x.ToList().Count, list = x.ToList() }).ToList();
            dataz.ForEach(x =>
            {
                if (x.count > 1)
                {
                    var first = x.list.First();
                    var same = x.list.Skip(1).Take(x.count - 1).ToList();
                    var fs = first.aname.Select(x => x).ToArray();
                    same.ForEach(z =>
                    {
                        var sp = z.aname.Select(x => x).ToArray();
                        int len = sp.Length;
                        if (sp.Length >= fs.Length)
                        {
                            len = fs.Count();
                        }
                        for (int index = 0; index < len; index++)
                        {
                            if (!$"{sp[index]}".Equals($"{fs[index]}"))
                            {
                                var spstr = ToPinYin($"{sp[index]}" );
                                var fsstr = ToPinYin($"{fs[index]}");
                                var insch= spstr.Select(x => $"{x}").Except( fsstr.Select(z => $"{z}"));
                                if (insch != null && insch.Count() > 0) {
                                    if (index > 1)
                                    {
                                        z.id = z.id.Insert(index - 1, insch.First()).Remove(index, 1);
                                    }
                                    else if (index == 1)  
                                    {
                                        z.id = z.id.Insert(index, insch.First()).Remove(index - 1, 1);
                                    }
                                }
                            }
                        }
                    });
                }
            });
            var dataa = dataz.SelectMany(y => y.list).GroupBy(x => x.id).Select(x => new { key = x.Key, more = x.ToList().Count > 2, count = x.ToList().Count, list = x.ToList() }).ToList();
            Random random = new Random();
            List<SchoolData> list = new List<SchoolData>();
            dataa.ForEach(x =>
            {
                if (x.count > 1)
                {
                    
                    x.list.ForEach(y => {
                        int r= random.Next(25);
                        int index= random.Next(5);
                        y.id   = y.id.Insert(index - 1, $"{a_z[r]}").Remove(index, 1);
                    });
                }
                list.AddRange(x.list);
            });

            return list; 
        }

        public static string ToPinYin(string val)
        {
            StringBuilder sb = new StringBuilder();
            val.ToCharArray().ToList().ForEach(x =>
            {
                if (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z') || ('0' <= x && x <= '9'))
                {
                    sb.Append(x);
                }
                else
                {
                    try
                    {
                        ChineseChar cc = new ChineseChar(x);
                        if (cc.Pinyins.Count > 0 && cc.Pinyins[0].Length > 0)
                        {
                            sb.Append(cc.Pinyins[0]);
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                }
            });
            return sb.ToString().ToLower();
        }
        public static string ToFirstPinYin(string val)
        {
            StringBuilder sb = new StringBuilder();
            val.ToCharArray().ToList().ForEach(x =>
            {
                if (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z') || ('0' <= x && x <= '9'))
                {
                    sb.Append(x);
                }
                else
                {
                    try
                    {
                        ChineseChar cc = new ChineseChar(x);
                        if (cc.Pinyins.Count > 0 && cc.Pinyins[0].Length > 0)
                        {
                            sb.Append(cc.Pinyins[0][0]);
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                }
            });
            return sb.ToString().ToLower();
        }
        public class SchoolData
        {
            public string province { get; set; }
            public string id { get; set; }
            public string name { get; set; }
            public string city { get; set; }
            public string aname { get; set; }
            public string uid { get; set; }
        }


        public static List<string> comeRemoveStr = new List<string>() { "省", "市", "区", "州", "县", "旗", "盟", "自治" };
        public static List<string> prvcRemoveStr = new List<string>() { "回族", "维吾尔", "壮族", };
        public static List<string> cityRemoveStr = new List<string>() { "蒙古族", "地区", "壮族", "朝鲜族", "直辖" };
        public static List<string> nationRemoveStr = new List<string> {
            "维吾尔","回族", "自治", "满族", "蒙古", "壮族", "苗族" , "侗族", "瑶族",
            "达斡尔","鄂温克","朝鲜","畲族","土家","各族","仫佬","毛南","羌族","彝族","仡佬","布依","水族",
            "傣族","纳西","哈尼","拉祜","佤族","傈僳","独龙","怒族","白族","普米","固族","哈萨克","土族","撒拉","景颇","族"
        };
        public static List<string> schemoveStr = new List<string> { "第", "校区", "部", "楼", "与", "学校", "校园", };
        public static List<string> schooRemoveStr = new List<string>() {"省", "市",  "区", "州", "县", "旗", "盟","办事处","街道", "自治",
           "镇","村","乡","街","路","站","馆"
        };
        public static List<string> afterSchoolRm = new List<string>() {"校","园","院", "湾","峡","沟","山","庄",
            "堡","江","屯","岭","溪","河","桥","营","铺","坡","寨","场","湖","巷","集","关","庙","寺","矿","塘"};
        public static List<KeyValuePair<string, string>> areaRemoveStr = new List<KeyValuePair<string, string>>{
            new KeyValuePair<string, string>("高新技术产业开发区", "高") ,
             new KeyValuePair<string, string>("经济技术开发区", "经") ,
            new KeyValuePair<string, string>("国际", "际") ,
            new KeyValuePair<string, string>("中国", ""),
            new KeyValuePair<string, string>("国家", ""),
            new KeyValuePair<string, string>("新区", ""),
            new KeyValuePair<string, string>("高新", "高"),
            new KeyValuePair<string, string>("园区", ""),
            new KeyValuePair<string, string>("产业", "产"),
            new KeyValuePair<string, string>("经济", "经"),
            new KeyValuePair<string, string>("开发", "开"),
            new KeyValuePair<string, string>("中心", "") ,
            new KeyValuePair<string, string>("集团", "") ,
            new KeyValuePair<string, string>("公司", "") ,
            new KeyValuePair<string, string>("有限", "") ,
            new KeyValuePair<string, string>("股份", "") ,
            new KeyValuePair<string, string>("服务", "") ,
            new KeyValuePair<string, string>("基地", "") ,
            new KeyValuePair<string, string>("社区", "社") ,
            new KeyValuePair<string, string>("职工", "") ,
            new KeyValuePair<string, string>("专修", ""),
            new KeyValuePair<string, string>("实验", "验"),
            new KeyValuePair<string, string>("完全", ""),
            new KeyValuePair<string, string>("一贯制", "") ,
            new KeyValuePair<string, string>("联办", ""),
            new KeyValuePair<string, string>("联合", ""),
            new KeyValuePair<string, string>("完小", "小"),
            new KeyValuePair<string, string>("义务", ""),
            new KeyValuePair<string, string>("基础", ""),
            new KeyValuePair<string, string>("制造", "")
        };
        public static List<KeyValuePair<string, string>> schooReplaceStr = new List<KeyValuePair<string, string>> {
            new KeyValuePair<string, string>("分校", "分") ,
            new KeyValuePair<string, string>("分园", "分") ,
            new KeyValuePair<string, string>("分院", "分") ,
            new KeyValuePair<string, string>("藏文", "藏"),
            new KeyValuePair<string, string>("职业技术学院", "职") ,
            new KeyValuePair<string, string>("创新创业", "创") ,
            new KeyValuePair<string, string>("就业创业", "就") ,
            new KeyValuePair<string, string>("应用核技术", "核") ,
            new KeyValuePair<string, string>("职业学院", "职") ,
            new KeyValuePair<string, string>("幼儿园", "幼") ,
            new KeyValuePair<string, string>("幼儿", "幼") ,
            new KeyValuePair<string, string>("小学", "小") ,
            new KeyValuePair<string, string>("中学", "中") ,
            new KeyValuePair<string, string>("中等", "中") ,
            new KeyValuePair<string, string>("双语", "双") ,
            new KeyValuePair<string, string>("初中", "初") ,
            new KeyValuePair<string, string>("初级", "初") ,
            new KeyValuePair<string, string>("广播", "广"),
            new KeyValuePair<string, string>("高中", "高") ,
            new KeyValuePair<string, string>("高级", "高") ,
            new KeyValuePair<string, string>("大学", "大") ,
            new KeyValuePair<string, string>("学院", "院") ,
            new KeyValuePair<string, string>("综合", "综") ,
            new KeyValuePair<string, string>("职业", "职") ,
            new KeyValuePair<string, string>("技术", "技") ,
            new KeyValuePair<string, string>("专科", "专") ,
            new KeyValuePair<string, string>("外国语", "外") ,

            new KeyValuePair<string, string>("九年", "九") ,
            new KeyValuePair<string, string>("五年", "五") ,
            new KeyValuePair<string, string>("年制", "制") ,
            new KeyValuePair<string, string>("高等", "高") ,

            new KeyValuePair<string, string>("院校", "院") ,
            new KeyValuePair<string, string>("初等", "小") ,
            new KeyValuePair<string, string>("附属", "附"),
            new KeyValuePair<string, string>("寄宿制", "寄") ,
            new KeyValuePair<string, string>("寄宿", "寄") ,
            new KeyValuePair<string, string>("卫生", "卫") ,
            new KeyValuePair<string, string>("创业", "创") ,
            new KeyValuePair<string, string>("继续", "继") ,
            new KeyValuePair<string, string>("开放", "开") ,
            new KeyValuePair<string, string>("技师", "技") ,
            new KeyValuePair<string, string>("成人", "成") ,
            new KeyValuePair<string, string>("教育", "教") ,
            new KeyValuePair<string, string>("科技", "科") ,
            new KeyValuePair<string, string>("行政", "政") ,
            new KeyValuePair<string, string>("生物", "生") ,
            new KeyValuePair<string, string>("美术", "美") ,
            new KeyValuePair<string, string>("设计", "设") ,
            new KeyValuePair<string, string>("传播", "传") ,
            new KeyValuePair<string, string>("计算机", "算") ,
            new KeyValuePair<string, string>("土木", "土") ,
            new KeyValuePair<string, string>("石油", "油") ,
            new KeyValuePair<string, string>("科普", "普") ,
            new KeyValuePair<string, string>("电信", "信") ,
            new KeyValuePair<string, string>("联合", "联") ,
            new KeyValuePair<string, string>("电商", "商") ,
            new KeyValuePair<string, string>("纺织", "织") ,
            new KeyValuePair<string, string>("服装", "服") ,
            new KeyValuePair<string, string>("新闻", "新") ,
            new KeyValuePair<string, string>("网络", "网") ,
            new KeyValuePair<string, string>("应用", "应") ,
            new KeyValuePair<string, string>("畜牧", "畜") ,
            new KeyValuePair<string, string>("兽医", "兽") ,
            new KeyValuePair<string, string>("师范", "师") ,
            new KeyValuePair<string, string>("人文", "文") ,
            new KeyValuePair<string, string>("创新", "创") ,
            new KeyValuePair<string, string>("法官", "法") ,
            new KeyValuePair<string, string>("邮电", "邮") ,
            new KeyValuePair<string, string>("文化", "文") ,
            new KeyValuePair<string, string>("函授", "函") ,
            new KeyValuePair<string, string>("科学", "科") ,
            new KeyValuePair<string, string>("信息", "息") ,
            new KeyValuePair<string, string>("水利", "利") ,
            new KeyValuePair<string, string>("水电", "电") ,
            new KeyValuePair<string, string>("电力", "力") ,
            new KeyValuePair<string, string>("环境", "环") ,
            new KeyValuePair<string, string>("建材", "材") ,
            new KeyValuePair<string, string>("机电", "机") ,
            new KeyValuePair<string, string>("航空", "空") ,
            new KeyValuePair<string, string>("航天", "天") ,
            new KeyValuePair<string, string>("警察", "警") ,
            new KeyValuePair<string, string>("警官", "警") ,
            new KeyValuePair<string, string>("财贸", "财") ,
            new KeyValuePair<string, string>("电子", "电") ,
            new KeyValuePair<string, string>("建筑", "筑") ,
            new KeyValuePair<string, string>("艺术", "艺") ,
            new KeyValuePair<string, string>("体育", "体") ,
            new KeyValuePair<string, string>("城市", "城") ,
            new KeyValuePair<string, string>("地质", "地") ,
            new KeyValuePair<string, string>("医药", "药") ,
            new KeyValuePair<string, string>("政法", "法") ,
            new KeyValuePair<string, string>("铁路", "铁") ,
            new KeyValuePair<string, string>("铁道", "道") ,
            new KeyValuePair<string, string>("轨道", "轨") ,
            new KeyValuePair<string, string>("交通", "通") ,
            new KeyValuePair<string, string>("医学院", "医") ,
            new KeyValuePair<string, string>("医学", "医") ,
            new KeyValuePair<string, string>("传媒", "媒") ,
            new KeyValuePair<string, string>("工程", "程") ,
            new KeyValuePair<string, string>("临床", "临") ,
            new KeyValuePair<string, string>("化工", "化") ,
            new KeyValuePair<string, string>("林业", "林") ,
            new KeyValuePair<string, string>("老年", "老") ,
            new KeyValuePair<string, string>("旅游", "游") ,
            new KeyValuePair<string, string>("护理", "护") ,
            new KeyValuePair<string, string>("贸易", "贸") ,
            new KeyValuePair<string, string>("中医药", "中医") ,
            new KeyValuePair<string, string>("资源", "源") ,
            new KeyValuePair<string, string>("冶金", "冶") ,
            new KeyValuePair<string, string>("能源", "能") ,
            new KeyValuePair<string, string>("汽车", "车") ,
            new KeyValuePair<string, string>("医科", "医") ,
            new KeyValuePair<string, string>("机械", "械") ,
            new KeyValuePair<string, string>("应用", "应") ,
            new KeyValuePair<string, string>("电气", "电") ,
            new KeyValuePair<string, string>("材料", "材") ,
            new KeyValuePair<string, string>("劳动", "劳") ,
            new KeyValuePair<string, string>("轻工", "轻") ,
            new KeyValuePair<string, string>("农业", "农") ,
            new KeyValuePair<string, string>("委员会", "委") ,
             new KeyValuePair<string, string>("专业", "专") ,
            new KeyValuePair<string, string>("广播", "广"),
            new KeyValuePair<string, string>("电视", "电") ,
            new KeyValuePair<string, string>("工商", "商") ,
            new KeyValuePair<string, string>("工业", "工") ,
            new KeyValuePair<string, string>("管理", "管") ,
            new KeyValuePair<string, string>("社会主义", "社") ,
            new KeyValuePair<string, string>("社会", "社") ,
            new KeyValuePair<string, string>("自动化", "自") ,



        };
        public static List<KeyValuePair<string, string>> proReplaceStr = new List<KeyValuePair<string, string>> {
            new KeyValuePair<string, string>("北京","京") ,
            new KeyValuePair<string, string>("天津","津") ,
            new KeyValuePair<string, string>("河北","冀") ,
            new KeyValuePair<string, string>("山西","晋") ,
            new KeyValuePair<string, string>("内蒙古","蒙") ,
            new KeyValuePair<string, string>("辽宁","辽") ,
            new KeyValuePair<string, string>("吉林","吉") ,
            new KeyValuePair<string, string>("黑龙江","黑") ,
            new KeyValuePair<string, string>("上海","沪") ,
            new KeyValuePair<string, string>("江苏","苏") ,
            new KeyValuePair<string, string>("浙江","浙") ,
            new KeyValuePair<string, string>("安徽","皖") ,
            new KeyValuePair<string, string>("福建","闽") ,
            new KeyValuePair<string, string>("江西","赣") ,
            new KeyValuePair<string, string>("山东","鲁") ,
            new KeyValuePair<string, string>("河南","豫") ,
            new KeyValuePair<string, string>("湖北","鄂") ,
            new KeyValuePair<string, string>("湖南","湘") ,
            new KeyValuePair<string, string>("广东","粤") ,
            new KeyValuePair<string, string>("广西","桂") ,
            new KeyValuePair<string, string>("海南","琼") ,
            new KeyValuePair<string, string>("四川","川") ,
            new KeyValuePair<string, string>("贵州","贵") ,
            new KeyValuePair<string, string>("云南","云") ,
            new KeyValuePair<string, string>("重庆","渝") ,
            new KeyValuePair<string, string>("西藏","藏") ,
            new KeyValuePair<string, string>("陕西","陕") ,
            new KeyValuePair<string, string>("甘肃","甘") ,
            new KeyValuePair<string, string>("青海","青") ,
            new KeyValuePair<string, string>("宁夏","宁") ,
            new KeyValuePair<string, string>("新疆","新") ,
            new KeyValuePair<string, string>("香港","港") ,
            new KeyValuePair<string, string>("澳门","澳") ,
            new KeyValuePair<string, string>("台湾","台")
        };

        /*
[
{"method":"台北市","params":{"CountryId":"TW","CityId":"30"}},1
{"method":"新北市","params":{"CountryId":"TW","CityId":"01"}},1
{"method":"桃园市","params":{"CountryId":"TW","CityId":"03"}},1
{"method":"台中市","params":{"CountryId":"TW","CityId":"66"}},1
{"method":"台南市","params":{"CountryId":"TW","CityId":"67"}},1
{"method":"高雄市","params":{"CountryId":"TW","CityId":"64"}},1
{"method":"基隆市","params":{"CountryId":"TW","CityId":"17"}},1
{"method":"新竹市","params":{"CountryId":"TW","CityId":"18"}},1
{"method":"嘉义市","params":{"CountryId":"TW","CityId":"20"}},1
{"method":"新竹县","params":{"CountryId":"TW","CityId":"04"}},1
{"method":"苗栗县","params":{"CountryId":"TW","CityId":"05"}},1
{"method":"彰化县","params":{"CountryId":"TW","CityId":"07"}},1
{"method":"南投县","params":{"CountryId":"TW","CityId":"08"}},1
{"method":"云林县","params":{"CountryId":"TW","CityId":"09"}},1
{"method":"嘉义县","params":{"CountryId":"TW","CityId":"10"}},1
{"method":"屏东县","params":{"CountryId":"TW","CityId":"13"}},1
{"method":"宜兰县","params":{"CountryId":"TW","CityId":"02"}},1
{"method":"花莲县","params":{"CountryId":"TW","CityId":"15"}},1
{"method":"台东县","params":{"CountryId":"TW","CityId":"14"}},1
{"method":"澎湖县","params":{"CountryId":"TW","CityId":"16"}},1
{"method":"金门县","params":{"CountryId":"TW","CityId":"71"}},
{"method":"连江县","params":{"CountryId":"TW","CityId":"72"}}
]

     */
    }
}