Example #1
0
 private static Premise PartialCopyPremise(Premise premise)
 {
     return(new Premise
     {
         RawAddress = premise.RawAddress,
         Account = premise.Account,
         Crn = premise.Crn,
         Tenant = premise.Tenant,
         BalanceTenancy = premise.BalanceTenancy,
         TotalArea = premise.TotalArea,
         LivingArea = premise.LivingArea,
         Prescribed = premise.Prescribed,
         ChargingTenancy = premise.ChargingTenancy,
         BalanceDgi = premise.BalanceDgi,
         BalancePadun = premise.BalancePadun,
         BalancePkk = premise.BalancePkk,
         BalanceInput = premise.BalanceInput,
         BalanceInputPenalties = premise.BalanceInputPenalties,
         TransferBalance = premise.TransferBalance,
         ChargingDgi = premise.ChargingDgi,
         ChargingPadun = premise.ChargingPadun,
         ChargingPkk = premise.ChargingPkk,
         ChargingTotal = premise.ChargingTotal,
         ChargingPenalties = premise.ChargingPenalties,
         BalanceOutputTenancy = premise.BalanceOutputTenancy,
         PaymentDgi = premise.PaymentDgi,
         PaymentPadun = premise.PaymentPadun,
         PaymentPkk = premise.PaymentPkk,
         PaymentTenancy = premise.PaymentTenancy,
         PaymentPenalties = premise.PaymentPenalties,
         RecalcTenancy = premise.RecalcTenancy,
         RecalcDgi = premise.RecalcDgi,
         RecalcPadun = premise.RecalcPadun,
         RecalcPkk = premise.RecalcPkk,
         RecalcPenalties = premise.RecalcPenalties,
         BalanceOutputTotal = premise.BalanceOutputTotal,
         BalanceOutputDgi = premise.BalanceOutputDgi,
         BalanceOutputPadun = premise.BalanceOutputPadun,
         BalanceOutputPkk = premise.BalanceOutputPkk,
         BalanceOutputPenalties = premise.BalanceOutputPenalties
     });
 }
Example #2
0
        static void Main(string[] args)
        {
            try
            {
                var arguments = ParseCommandLineArgs(args);
                if (!arguments.ContainsKey("bks-file") || !File.Exists(arguments["bks-file"]))
                {
                    throw new ApplicationException("CSV file from BKS not found");
                }
                if (!arguments.ContainsKey("sphinx-connection-string"))
                {
                    throw new ApplicationException("Sphinx connction string is require");
                }
                if (!arguments.ContainsKey("db-connection-string"))
                {
                    throw new ApplicationException("Database 'registry' connction string is require");
                }

                // Загружаем адреса
                var addresses = LoadPremises(arguments["bks-file"]);

                var groupedAccounts = from row in addresses
                                      group row by new { row.CRN, row.Account, row.Tenant, row.RawAddress }
                into gs
                    select new
                {
                    gs.Key.CRN,
                    gs.Key.Account,
                    gs.Key.Tenant,
                    gs.Key.RawAddress,
                    Steps = gs
                };

                var premises = new List <Premise>();
                var premise  = new Premise();

                foreach (var group in groupedAccounts)
                {
                    premise.Account    = group.Account;
                    premise.RawAddress = group.RawAddress;
                    premise.Crn        = group.CRN;
                    premise.Tenant     = group.Tenant;

                    var account = group.Steps.Where(s => s.RawType == "Лицевой счет").ToList();
                    if (account.Any())
                    {
                        var accountFirst = account.First();
                        premise.TotalArea  = accountFirst.TotalArea;
                        premise.LivingArea = accountFirst.LivingArea;
                        premise.Prescribed = accountFirst.Prescribed;
                    }
                    else
                    {
                        premise.TotalArea  = "0";
                        premise.LivingArea = "0";
                        premise.Prescribed = "0";
                    }
                    var balanceInput = group.Steps.Where(s => s.RawType == "Вх. сальдо").ToList();
                    if (balanceInput.Any())
                    {
                        var balanceInputFirst = balanceInput.First();
                        premise.BalanceInput          = balanceInputFirst.BalanceInput;
                        premise.BalanceTenancy        = balanceInputFirst.BalanceTenancy;
                        premise.BalanceDgi            = balanceInputFirst.DzDgi;
                        premise.BalancePadun          = balanceInputFirst.DzPadun;
                        premise.BalancePkk            = balanceInputFirst.DzPkk;
                        premise.BalanceInputPenalties = balanceInputFirst.Penalties;
                    }
                    else
                    {
                        premise.BalanceInput          = "0";
                        premise.BalanceTenancy        = "0";
                        premise.BalanceDgi            = "0";
                        premise.BalancePadun          = "0";
                        premise.BalancePkk            = "0";
                        premise.BalanceInputPenalties = "0";
                    }
                    var charging = group.Steps.Where(s => s.RawType == "Начислено (расчет)").ToList();
                    if (charging.Any())
                    {
                        var chargingFirst = charging.First();
                        premise.ChargingPenalties = chargingFirst.Penalties;
                        premise.ChargingTenancy   = chargingFirst.BalanceTenancy;
                    }
                    else
                    {
                        premise.ChargingTenancy   = "0";
                        premise.ChargingPenalties = "0";
                    }
                    var chargingTotal = group.Steps.Where(s => s.RawType == "Начислено (итого)").ToList();
                    if (chargingTotal.Any())
                    {
                        var chargingTotalFirst = chargingTotal.First();
                        premise.ChargingTotal = chargingTotalFirst.BalanceTenancy;
                        premise.ChargingDgi   = chargingTotalFirst.DzDgi;
                        premise.ChargingPadun = chargingTotalFirst.DzPadun;
                        premise.ChargingPkk   = chargingTotalFirst.DzPkk;
                    }
                    else
                    {
                        premise.ChargingTotal = "0";
                        premise.ChargingDgi   = "0";
                        premise.ChargingPadun = "0";
                        premise.ChargingPkk   = "0";
                    }
                    var recalc = group.Steps.Where(s => s.RawType == "Разовые (перерасчеты").ToList();
                    if (recalc.Any())
                    {
                        var recalcFirst = recalc.First();
                        premise.RecalcTenancy   = recalcFirst.BalanceTenancy;
                        premise.RecalcDgi       = recalcFirst.DzDgi;
                        premise.RecalcPadun     = recalcFirst.DzPadun;
                        premise.RecalcPkk       = recalcFirst.DzPkk;
                        premise.RecalcPenalties = recalcFirst.Penalties;
                    }
                    else
                    {
                        premise.RecalcTenancy   = "0";
                        premise.RecalcDgi       = "0";
                        premise.RecalcPadun     = "0";
                        premise.RecalcPkk       = "0";
                        premise.RecalcPenalties = "0";
                    }
                    var payment = group.Steps.Where(s => s.RawType == "Оплачено").ToList();
                    if (payment.Any())
                    {
                        var paymentFirst = payment.First();
                        premise.PaymentTenancy   = paymentFirst.BalanceTenancy;
                        premise.PaymentDgi       = paymentFirst.DzDgi;
                        premise.PaymentPadun     = paymentFirst.DzPadun;
                        premise.PaymentPkk       = paymentFirst.DzPkk;
                        premise.PaymentPenalties = paymentFirst.Penalties;
                    }
                    else
                    {
                        premise.PaymentTenancy   = "0";
                        premise.PaymentDgi       = "0";
                        premise.PaymentPadun     = "0";
                        premise.PaymentPkk       = "0";
                        premise.PaymentPenalties = "0";
                    }
                    var transferBalance = group.Steps.Where(s => s.RawType == "Перенос сальдо").ToList();
                    if (transferBalance.Any())
                    {
                        var transferBalanceFirst = transferBalance.First();
                        premise.TransferBalance = transferBalanceFirst.BalanceTenancy;
                    }
                    else
                    {
                        premise.TransferBalance = "0";
                    }

                    var balanceOutput = group.Steps.Where(s => s.RawType == "Исх. сальдо").ToList();
                    if (balanceOutput.Any())
                    {
                        var balanceOutputFirst = balanceOutput.First();
                        premise.BalanceOutputTotal     = balanceOutputFirst.BalanceOutput;
                        premise.BalanceOutputTenancy   = balanceOutputFirst.BalanceTenancy;
                        premise.BalanceOutputDgi       = balanceOutputFirst.DzDgi;
                        premise.BalanceOutputPadun     = balanceOutputFirst.DzPadun;
                        premise.BalanceOutputPkk       = balanceOutputFirst.DzPkk;
                        premise.BalanceOutputPenalties = balanceOutputFirst.Penalties;
                    }
                    else
                    {
                        premise.BalanceOutputTotal     = "0";
                        premise.BalanceOutputTenancy   = "0";
                        premise.BalanceOutputDgi       = "0";
                        premise.BalanceOutputPadun     = "0";
                        premise.BalanceOutputPkk       = "0";
                        premise.BalanceOutputPenalties = "0";
                    }
                    premises.Add(premise);
                    premise = new Premise();
                }

                using (var sphinx = new MySqlConnection(arguments["sphinx-connection-string"]))
                    using (var connection = new DatabaseConnection(arguments["db-connection-string"]))
                    {
                        sphinx.Open();
                        // Парсим адреса
                        var addressesParser = new AddressesParser(premises, Logger);
                        // Привязываем идентификаторы помещений и комнат для корректно распарсеных адресов
                        var addressesSearcher = new AddressesSearcher(sphinx, connection, Logger);
                        foreach (var address in addressesParser.PreparedPremises)
                        {
                            addressesSearcher.SearchIds(address); // Корректирует идентификаторы у переданного объекта!!!
                        }
                        // Сохраняем в базу данных полученую информацию
                        var dbInserter = new DbInserter(connection, Logger);
                        dbInserter.InsertIntoDb(addressesParser.PreparedPremises, addressesParser.InvalidPremises);
                    }
                Console.ReadLine();
            }
            catch (Exception e)
            {
                Logger.Write(e.Message, MsgType.ErrorMsg);
                Console.ReadLine();
            }
        }
Example #3
0
        private static List <List <Premise> > ParseRawAddress(Premise premiseAddress)
        {
            const string regExpression = @"^(?:ул\.?[ ]+|пер\.?[ ]+|пр-кт\.?[ ]+|бул\.?[ ]+|б-р\.?[ ]+|проезд\.?[ ]+)?(.*?)(?:[ ]+ул\.?|[ ]+пер\.?|[ ]+пр-кт\.?|[ ]+бул\.?|[ ]+б-р\.?|[ ]+проезд\.?)?(?:[ ]*,|,?[ ]*дом\.?|,?[ ]*д\.?)[ ]*([0-9]+[ """"\-]*[а-яА-Я]?[ """"\-]*(?:[ ]*[\/\\][ ]*[0-9]+[ """"\-]*[а-яА-Я]?[ """"\-]*)?).*?(?:,?[ ]*квартира\.?|,?[ ]*кв\.?[ ]*комн\.?|,?[ ]*кв\.?[ ]*ком\.?|,?[ ]*кв\.?[ ]*пом\.?|,?[ ]*кв\.?[ ]*к\.?|,?[ ]*кв\.?)[ ]*([0-9]+[ ]*[а-дА-Д]?(?:[ ]*(?:[ ]*-[ ]*|[ ]*,[ ]*|,?[ ]*квартира\.?|,?[ ]*кв\.?[ ]*комн\.?|,?[ ]*кв\.?[ ]*ком\.?|,?[ ]*кв\.?[ ]*пом\.?|,?[ ]*кв\.?[ ]*к\.?|,?[ ]*кв\.?)[ ]*(?:[0-9]+[ ]*[а-дА-Д]?))*)(.*)$";
            var          matches       = Regex.Match(premiseAddress.RawAddress.Trim().ToLower(), regExpression);

            if (matches.Groups.Count < 4)
            {
                var copyPremise = PartialCopyPremise(premiseAddress);
                copyPremise.Description = "Invalid parse address";
                var emptyAddress = new List <List <Premise> >
                {
                    new List <Premise> {
                        copyPremise
                    }
                };
                return(new List <List <Premise> >(emptyAddress));
            }
            var    sleshedRooms = false;
            var    street       = matches.Groups[1].Value;
            var    house        = AddressHelper.NormalizeHouse(matches.Groups[2].Value);
            var    premises     = AddressHelper.NormalizePremises(matches.Groups[3].Value);
            string subPremises  = null;

            if (matches.Groups.Count > 4)
            {
                subPremises = AddressHelper.NormalizeSubPremises(matches.Groups[4].Value);
                subPremises = subPremises.Trim(',');
                if (subPremises.StartsWith("/"))
                {
                    sleshedRooms = true;
                    subPremises  = subPremises.Trim('/').Replace('/', ',');
                }
            }
            var addresses = new List <List <Premise> >();

            if (string.IsNullOrEmpty(subPremises))
            {
                var newAddress = PartialCopyPremise(premiseAddress);
                newAddress.SubPremises   = new List <SubPremise>();
                newAddress.PremiseNumber = premises;
                newAddress.House         = house;
                newAddress.Street        = street;
                addresses.Add(new List <Premise> {
                    newAddress
                });
                var premisesArray = premises.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                if (premisesArray.Length <= 1)
                {
                    return(addresses);
                }
                var newAddressesList = new List <Premise>();
                foreach (var premise in premisesArray)
                {
                    newAddress               = PartialCopyPremise(premiseAddress);
                    newAddress.SubPremises   = new List <SubPremise>();
                    newAddress.PremiseNumber = premise;
                    newAddress.House         = house;
                    newAddress.Street        = street;
                    newAddressesList.Add(newAddress);
                }
                addresses.Add(newAddressesList);
            }
            else
            {
                var newAddress = PartialCopyPremise(premiseAddress);
                newAddress.Street        = street;
                newAddress.House         = house;
                newAddress.PremiseNumber = premises;
                newAddress.SubPremises   = new List <SubPremise>();
                var subPremisesArray = subPremises.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var subPremise in subPremisesArray)
                {
                    newAddress.SubPremises.Add(new SubPremise {
                        SubPremiseNumber = subPremise
                    });
                }
                addresses.Add(new List <Premise> {
                    newAddress
                });

                var subPremisesList = subPremises.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                if (sleshedRooms && !Regex.IsMatch(subPremises, @"[А-Я](,[А-Я])*"))
                {
                    for (var i = 1; i <= subPremisesList.Length; i++)
                    {
                        newAddress               = PartialCopyPremise(premiseAddress);
                        newAddress.Street        = street;
                        newAddress.House         = house;
                        newAddress.PremiseNumber = premises + "," +
                                                   subPremisesList.Take(i).Aggregate((v, acc) => v + "," + acc);
                        newAddress.SubPremises = subPremisesList.Length > 1
                            ? subPremisesList.Skip(i)
                                                 .Select(subPremise => new SubPremise {
                            SubPremiseNumber = subPremise
                        })
                                                 .ToList()
                            : new List <SubPremise>();
                        addresses.Add(new List <Premise> {
                            newAddress
                        });
                    }
                    if (subPremisesList.Length > 0)
                    {
                        var premisesArray = (premises + "," + subPremisesList.Aggregate((v, acc) => v + "," + acc)).
                                            Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        var newAddressesList = new List <Premise>();
                        foreach (var premise in premisesArray)
                        {
                            newAddress               = PartialCopyPremise(premiseAddress);
                            newAddress.Street        = street;
                            newAddress.House         = house;
                            newAddress.PremiseNumber = premise;
                            newAddress.SubPremises   = new List <SubPremise>();
                            newAddressesList.Add(newAddress);
                        }
                        addresses.Add(newAddressesList);
                    }
                }
            }
            return(addresses);
        }