private AnalysisAddressNewResultItem AnalysisDistrict(AnalysisAddressNewItem item, List <District> districts, AnalysisAddressNewResultItem currentResultItem, out string analysisAddress)
        {
            var rs = currentResultItem;

            analysisAddress = item.Address.Trim().ToLower();
            var district = new District();

            //Nếu tên quận / huyện có trong dữ liệu truyền vào
            if (!string.IsNullOrEmpty(item.DistrictName))
            {
                //Loại bỏ những tiền tố, hậu tố thừa đi
                item.DistrictName = item.DistrictName.Trim().ToLower();

                var districtNames = new List <string>()
                {
                    item.DistrictName, item.DistrictName.ConvertToUnsign()
                };
                district =
                    districts.FirstOrDefault(c =>
                                             districtNames.Any(dn => dn.Contains(c.Name.ToLower())) ||
                                             districtNames.Any(dn => dn.Contains(c.UnsignName.ToLower())) ||
                                             c.Exceptions.Any(ex => districtNames.Contains(ex.Name.ToLower()))
                                             );
            }
            if (district == null || district.Id <= 0)
            {
                //Sắp xếp theo thứ tự hiển thị
                districts = districts.Where(d => d.CityId == currentResultItem.CityId).OrderBy(c => c.DisplayOrder).ToList();
                if (districts.Any())
                {
                    var add         = analysisAddress;
                    var unsignedAdd = analysisAddress.ConvertToUnsign();
                    //Phân tích từ địa chỉ ra
                    foreach (var districtCheck in districts)
                    {
                        var districtCheckName    = districtCheck.Name.ToLower();
                        var districtNameToUnsign = districtCheckName.ConvertToUnsign();
                        var districtNames        = new List <string>()
                        {
                            "quận " + districtCheckName
                            , "quận" + districtCheckName
                            , "quận." + districtCheckName
                            , "quan " + districtCheckName
                            , "quan." + districtCheckName

                            , "q" + districtCheckName
                            , "q " + districtCheckName
                            , "q." + districtCheckName

                            , "quận " + districtNameToUnsign
                            , "quận" + districtNameToUnsign
                            , "quận." + districtNameToUnsign
                            , "quan " + districtNameToUnsign
                            , "quan." + districtNameToUnsign

                            , "q" + districtNameToUnsign
                            , "q " + districtNameToUnsign
                            , "q." + districtNameToUnsign
                            , "q. " + districtNameToUnsign
                        };
                        if (!districtCheckName.IsNumber())
                        {
                            districtNames.Add(districtCheckName);
                            districtNames.Add(districtCheckName.ConvertToUnsign());
                        }
                        var districtExceptions = districtCheck.Exceptions.Where(e => !e.IsDeleted).Select(e => e.Name.ToLower()).ToList();
                        if (districtExceptions.Any())
                        {
                            var unsignedExceptions = districtExceptions.Select(e => e.ConvertToUnsign()).ToList();
                            districtExceptions.AddRange(unsignedExceptions);
                            districtNames.AddRange(districtExceptions);
                        }

                        if (!districtNames.Any(w => add.Contains(w)) && !districtNames.Any(w => unsignedAdd.Contains(w)))
                        {
                            continue;
                        }
                        var foundDistrictName = districtNames.FirstOrDefault(w => add.Contains(w) || unsignedAdd.Contains(w));
                        district = districtCheck;
                        if (analysisAddress.LastIndexOf(foundDistrictName, StringComparison.Ordinal) > 0)
                        {
                            analysisAddress = analysisAddress.ReplaceLastOccur(foundDistrictName);
                        }
                        break;
                    }
                }
                else
                {
                    rs.Result  = Result.Failed;
                    rs.Message = "Không tìm thấy quận / huyện nào";
                }
            }
            if (district != null && district.Id > 0)
            {
                rs.DistrictId   = district.Id;
                rs.DistrictName = district.Name;
            }
            else
            {
                rs.Result  = Result.Failed;
                rs.Message = "Không phân tích được quận / huyện";
            }
            return(rs);
        }
        private AnalysisAddressNewResultItem AnalysisWard(AnalysisAddressNewItem item, List <Ward> wards, AnalysisAddressNewResultItem currentResultItem)
        {
            var rs = currentResultItem;
            var analysisAddress = item.Address.Trim().ToLower();
            var ward            = new Ward();

            //Nếu tên quận / huyện có trong dữ liệu truyền vào
            if (!string.IsNullOrEmpty(item.WardName))
            {
                //Loại bỏ những tiền tố, hậu tố thừa đi
                item.WardName = item.WardName.Trim().ToLower();

                var wardNames = new List <string>()
                {
                    item.WardName, item.WardName.Unsigned()
                };
                ward =
                    wards.FirstOrDefault(c =>
                                         wardNames.Any(wn => wn.Contains(c.Name.ToLower())) ||
                                         wardNames.Any(wn => wn.Contains(c.UnsignName.ToLower())) ||
                                         c.Exceptions.Any(ex => wardNames.Contains(ex.Name.ToLower()))
                                         );
            }

            //Nếu tên quận / huyện không có trong dữ liệu truyền vào hoặc không phân tích được thì lấy tiếp tới địa chỉ
            if (ward == null || ward.Id <= 0)
            {
                //Sắp xếp theo thứ tự hiển thị
                wards = wards.Where(d => d.DistrictId == currentResultItem.DistrictId).OrderBy(c => c.DisplayOrder).ToList();
                if (wards.Any())
                {
                    var add         = analysisAddress;
                    var addUnsigned = analysisAddress.ConvertToUnsign();
                    //Phân tích từ địa chỉ ra
                    foreach (var wardCheck in wards)
                    {
                        var wardCheckName         = wardCheck.Name.ToLower();
                        var wardCheckNameToUnsign = wardCheckName.ConvertToUnsign();
                        var wardNames             = new List <string>()
                        {
                            "phường " + wardCheckName
                            , "phường" + wardCheckName
                            , "phường." + wardCheckName

                            , "phuong " + wardCheckName
                            , "phuong" + wardCheckName
                            , "phuong." + wardCheckName

                            , "p " + wardCheckName
                            , "p" + wardCheckName
                            , "p." + wardCheckName

                            , "xã " + wardCheckName
                            , "xã" + wardCheckName
                            , "xã." + wardCheckName
                            , "xa " + wardCheckName
                            , "xa" + wardCheckName
                            , "xa." + wardCheckName

                            , "x " + wardCheckName
                            , "x" + wardCheckName
                            , "x." + wardCheckName

                            , wardCheckName

                            , wardCheckNameToUnsign
                            , "phuong " + wardCheckNameToUnsign
                            , "phuong" + wardCheckNameToUnsign
                            , "phuong." + wardCheckNameToUnsign

                            , "xa " + wardCheckNameToUnsign
                            , "xa" + wardCheckNameToUnsign
                            , "xa." + wardCheckNameToUnsign

                            , "x " + wardCheckNameToUnsign
                            , "x" + wardCheckNameToUnsign
                            , "x." + wardCheckNameToUnsign
                        };
                        var wardExceptions = wardCheck.Exceptions.Where(ex => !ex.IsDeleted).Select(e => e.Name.ToLower()).ToList();
                        if (wardExceptions.Any())
                        {
                            var unsignedExceptions = wardExceptions.Select(e => e.ConvertToUnsign()).ToList();
                            wardExceptions.AddRange(unsignedExceptions);
                            wardNames.AddRange(wardExceptions);
                        }

                        if (!wardNames.Any(w => add.Contains(w)) && !wardNames.Any(w => addUnsigned.Contains(w)))
                        {
                            continue;
                        }
                        ward = wardCheck;
                        break;
                    }
                }
                else
                {
                    rs.Result  = Result.Failed;
                    rs.Message = "Không tìm thấy phường / xã nào";
                }
            }

            if (ward != null && ward.Id > 0)
            {
                var isoutofserve = false;
                if (ward.IsInServe == false)
                {
                    isoutofserve = true;
                }
                rs.WardId       = ward.Id;
                rs.WardName     = ward.Name;
                rs.IsOutOfServe = isoutofserve;
            }
            else
            {
                rs.Result  = Result.Failed;
                rs.Message = "Không phân tích được phường / xã";
            }
            return(rs);
        }
        private AnalysisAddressNewResultItem AnalysisCity(AnalysisAddressNewItem item, List <City> cities, AnalysisAddressNewResultItem currentResultItem, out string analysisAddress)
        {
            var rs = currentResultItem;

            analysisAddress = item.Address.Trim().ToLower();
            var city = new City();

            //Nếu tên thành phố có trong dữ liệu truyền vào
            if (!string.IsNullOrEmpty(item.CityName))
            {
                //Loại bỏ những tiền tố, hậu tố thừa đi
                item.CityName = item.CityName.Trim().ToLower();
                var cityTrim  = item.CityName.Trim();
                var cityNames = new List <string>()
                {
                    cityTrim.ToLower(),
                    cityTrim.ToLower().Unsigned(),
                    cityTrim.ToUpper(),
                    cityTrim.ToUpper().Unsigned()
                };
                city =
                    cities.FirstOrDefault(c => cityNames.Any(cn => cn.Contains(c.Name.Trim().ToLower())) ||
                                          cityNames.Any(cn => cn.Contains(c.UnsignName.ToLower())) ||
                                          c.Exceptions.Any(ex => cityNames.Contains(ex.Name.ToLower())) ||
                                          cityNames.Any(cn => cn.Contains(c.Name.Trim().ToUpper())) ||
                                          cityNames.Any(cn => cn.Contains(c.UnsignName.ToUpper())) ||
                                          c.Exceptions.Any(ex => cityNames.Contains(ex.Name.ToUpper()))
                                          );
            }
            //Nếu không phân tích được ở cột tỉnh / thành phố thì phân tích tiếp ở địa chỉ
            if (city == null || city.Id <= 0)
            {
                //Sắp xếp theo thứ tự hiển thị
                cities = cities.OrderBy(c => c.DisplayOrder).ToList();
                var add           = analysisAddress;
                var listCharacter = new List <string> {
                    ",", ";", "/", ";", ":", "-", "_", "."
                };
                //Phân tích từ địa chỉ ra
                foreach (var cityCheck in cities)
                {
                    var cityNames = new List <string>()
                    {
                        cityCheck.Name.ToLower(),
                             cityCheck.UnsignName
                    };
                    var cityExceptions = cityCheck.Exceptions.Where(e => !e.IsDeleted).Select(e => e.Name.ToLower()).ToList();
                    if (cityExceptions.Any())
                    {
                        var unsignedExceptions   = cityExceptions.Select(e => e.ConvertToUnsign()).ToList();
                        var cityExceptionsUppper = cityCheck.Exceptions.Where(e => !e.IsDeleted).Select(e => e.Name.ToLower()).ToList();
                        cityExceptions.AddRange(unsignedExceptions);
                        cityExceptions.AddRange(cityExceptionsUppper);
                        cityNames.AddRange(cityExceptions);
                    }
                    if (listCharacter.Any(x => add.EndsWith(x)))
                    {
                        char c = add.Last();
                        add = add.Trim(c);
                    }

                    if (!cityNames.Any(w => add.EndsWith(w)))
                    {
                        continue;
                    }
                    var foundCityName = cityNames.FirstOrDefault(w => add.EndsWith(w));
                    city = cityCheck;
                    if (analysisAddress.LastIndexOf(foundCityName, StringComparison.Ordinal) > 0)
                    {
                        analysisAddress = analysisAddress.Substring(0, analysisAddress.LastIndexOf(foundCityName, StringComparison.Ordinal));
                    }
                    break;
                }
            }
            if (city != null && city.Id > 0)
            {
                rs.CityId   = city.Id;
                rs.CityName = city.Name;
            }
            else
            {
                rs.Result  = Result.Failed;
                rs.Message = "Không phân tích được thành phố";
            }
            return(rs);
        }