int WczytajWładających(DokumentSwde swde)
{
var wladajacy = swde.GetObiektyKlasy("G5UDW");
foreach (var klu in wladajacy)
{
var jdr = klu.GetRelacja("G5RWŁD"); //Jednostka rejestrowa? (opcjonalna)
string g5ijr = jdr.GetAtrybut("G5IJR");
JednostkaRejestrowa jr = _indeksJednostek[JednostkaRejestrowa.ParseG5(g5ijr).ToString()];
var pod = klu.GetRelacja("G5RPOD"); //Podmiot
switch (pod.Typ)
{
case "G5OSF":
jr.DodajWladajacego(pod.CreateOsobaFizyczna());
break;
case "G5INS":
jr.DodajWladajacego(pod.CreateInstytucja());
break;
case "G5MLZ":
jr.DodajWladajacego(pod.CreateMałżeństwo());
break;
case "G5OSZ":
jr.DodajWladajacego(pod.CreatePodmiotGrupowy());
break;
default: Kontrakt.fail(); break;
}
}
return(wladajacy.Count());
}
public IEnumerable <DzialkaEwidencyjna> dzialkiDotychczasowePodzielone()
{
Dictionary <string, DzialkaEwidencyjna> podzieloneDzialki = new Dictionary <string, DzialkaEwidencyjna>();
List <DzialkaEwidencyjna> posortowaneDzialki = new List <DzialkaEwidencyjna>();
foreach (var dzialka in this)
{
//Pomiń działki bez zdefiniowanej działki ewidencyjnej.
if (!dzialka.przypisanaDotychczasowa())
{
continue;
}
DzialkaEwidencyjna dzialkaDotychczasowa = dzialka.dzialkaDotychczasowa();
//Pomiń działki niepodzielone.
if (dzialkaDotychczasowa.countPodzielone() == 0)
{
continue;
}
//Działka nowa powinna mieć inny identyfikator niż działka dotychczasowa!
Kontrakt.assert(!dzialka.identyfikator().Equals(dzialkaDotychczasowa.identyfikator()),
"Identyfikator nowej działki jest taki sam jak dotychczasowej.");
string idPodzielona = dzialkaDotychczasowa.identyfikator().ToString();
if (!podzieloneDzialki.ContainsKey(idPodzielona))
{
podzieloneDzialki.Add(idPodzielona, dzialkaDotychczasowa);
posortowaneDzialki.Add(dzialkaDotychczasowa);
}
}
return(posortowaneDzialki);
}
public IEnumerable <DzialkaEwidencyjna> działki()
{
var powierzchnia = new Powierzchnia(1);
foreach (var dze in _dokument.GetObiektyKlasy("G5DZE"))
{
var g5idd = dze.GetAtrybut("G5IDD");
var id = IdentyfikatorDzialki.parseG5(g5idd);
var działka = new DzialkaEwidencyjna(id, powierzchnia);
//Nie dodawaj do działki punktów jeżeli choć jeden jest niegraniczny, aby wymusić status "nieznany" dla działki.
if (dze.Geometria.countPunktyNiegraniczne() == 0)
{
Kontrakt.assert(działka.countPunkty() == 0, "Do działki były już importowane punkty.");
ObiektSwde[] punktySwde = dze.Geometria.PunktyGraniczne;
foreach (var punktSwde in punktySwde)
{
string g5zrd = punktSwde.GetAtrybut("G5ZRD");
string g5bpp = punktSwde.GetAtrybut("G5BPP");
var punkt = new PunktGraniczny(g5zrd, g5bpp);
ObiektSwde operat = punktSwde.GetRelacja("G5RKRG");
string g5syg = operat.GetAtrybut("G5SYG");
punkt.operat(g5syg);
działka.dodajPunkt(punkt);
}
}
yield return(działka);
}
}
public static IdentyfikatorDzialki parseG5(string g5idd)
{
//D,G5IDD,D,142302_2.0001.296
//D,G5IDD,D,142302_2.0007.AR_2.656
//<teryt>.<obr>.[arkusz].<idd>
char[] separator = new char[] { '.' };
string[] pola = g5idd.Split(separator);
int maxFields = 4;
int minFields = 3;
Kontrakt.assert(pola.Length >= minFields && pola.Length <= maxFields);
string numerTeryt = pola[0];
string numerObrebu = byte.Parse(pola[1]).ToString();
string numerDzialki = pola[pola.Length - 1];
string numerArkusza = string.Empty;
if (pola.Length == 4)
{
numerArkusza = pola[2].Replace("AR_", "");
}
if (!string.IsNullOrEmpty(numerArkusza))
{
numerDzialki = numerArkusza + "." + numerDzialki;
}
return(new IdentyfikatorDzialki(numerObrebu, numerDzialki));
}
public void Wczytaj(string fileName)
{
//_klu.read(Path.Combine(Path.GetDirectoryName(fileName), "uzytkiG5.csv"));
var lines = File.ReadAllLines(path: fileName, encoding: _kodowanie);
var header = lines.First();
Kontrakt.assert(
header.Equals("Rozliczenie konturów klasyfikacyjnych na działkach [m^2]"),
"Nieprawidłowy nagłówek pliku z rozliczeniem konturów.");
var wczytaneDziałki = 0;
var rekordDziałki = new List <string>();
for (int i = 1; i < lines.Length; i++)
{
var trimmedLine = lines[i].Trim();
if (KoniecRekorduDziałki(rekordDziałki, trimmedLine))
{
WczytajRekordDziałki(_rozliczenie, rekordDziałki);
wczytaneDziałki++;
}
else
{
//Kumulacja rekordu działki wraz z użytkami.
if (!String.IsNullOrEmpty(trimmedLine))
{
rekordDziałki.Add(trimmedLine);
}
}
}
Kontrakt.ensures(rekordDziałki.Count == 0, "Nieprawidłowo zakończony rekord działki");
Kontrakt.ensures(_rozliczenie.Any());
Kontrakt.ensures(wczytaneDziałki == _rozliczenie.Count());
}
public static PodmiotGrupowy CreatePodmiotGrupowy(this ObiektSwde podmiotGrupowy)
{
string npe = podmiotGrupowy.GetAtrybut("G5NPE");
string nsk = podmiotGrupowy.GetAtrybut("G5NSK");
PodmiotGrupowy pg = new PodmiotGrupowy(string.IsNullOrEmpty(npe) ? nsk : npe);
var podmioty = podmiotGrupowy.GetRelacjaWielokrotna("G5RSKD"); //Składa się
foreach (var podmiot in podmioty)
{
switch (podmiot.Typ)
{
case "G5OSF":
pg.dodajPodmiot(CreateOsobaFizyczna(podmiot));
break;
case "G5INS":
pg.dodajPodmiot(CreateInstytucja(podmiot));
break;
case "G5MLZ":
pg.dodajPodmiot(CreateMałżeństwo(podmiot));
break;
default: Kontrakt.fail(); break;
}
}
return(pg);
}
public void resetEwidencja(DzialkaEwidencyjna dzialka)
{
Kontrakt.requires(dzialka._dzialkiPodzielone.Count == 0);
Kontrakt.requires(dzialka.jednostkaRejestrowa() != null, "Działka ewidencyjna nie ma przypisanej jednostki rejestrowej.");
Kontrakt.requires(dzialka.countKlasouzytki() > 0, "Działka ewidencyjna nie ma żadnych użytków.");
_dzialkaDotychczasowa = dzialka;
}
public void DodajDziałkę(Działka działka)
{
if (działka == null)
{
throw new ArgumentNullException(paramName: "działka", message: "Działka jest null.");
}
if (działka.Any() == false)
{
throw new InvalidOperationException(message: "Działka nie zawiera żadnych klasoużytków.");
}
if (SzukajIdDziałki(działka.Id) != null)
{
throw new InvalidOperationException("Rozliczenie zawiera już działkę " + działka.Id);
}
int dzialkiPrzed = _działki.Count;
_działki.Add(działka);
var id = działka.Id;
_indeksDziałek.Add(id.ToString(), działka);
int dzialkiPo = _działki.Count;
Kontrakt.ensures(dzialkiPrzed + 1 == dzialkiPo);
Kontrakt.ensures(SzukajIdDziałki(id) != null);
}
public static bool uległaZmianie(this Działka staraDzialka, Działka nowaDzialka)
{
if (!nowaDzialka.Powierzchnia.Equals(staraDzialka.Powierzchnia))
{
return(true); //niezgodna powierzchnia działki
}
if (nowaDzialka.Count() != staraDzialka.Count())
{
return(true); //niezgodna liczba użytków
}
var użytki = staraDzialka.UnionUżytki(nowaDzialka);
foreach (var użytek in użytki)
{
Klasoużytek stary = staraDzialka.SzukajUżytku(użytek);
Klasoużytek nowy = nowaDzialka.SzukajUżytku(użytek);
if (stary == null || nowy == null)
{
return(true); //dodany/usunięty użytek
}
Powierzchnia stara = stary.powierzchnia();
Powierzchnia nowa = nowy.powierzchnia();
if (!nowa.Equals(stara))
{
return(true); //inna powierzchnia użytków
}
//if (nowa.powyzejOdchylki(stara)) return true; //powyżej odchyłki
Kontrakt.assert(stary.Equals(nowy), "Różne oznaczenie użytku: " + stary.ToString());
}
return(false);
}
public void read(string fileName)
{
//OZN,OFU,OZU,OZK,OPIS,OFUst,OZUst,OZKst,
//"B","B",,,"Tereny mieszkaniowe",,"B",,
string[] lines = File.ReadAllLines(fileName, Encoding.GetEncoding(1250));
string header = lines.First();
Kontrakt.assert(header.StartsWith("OZN,OFU,OZU,OZK,OPIS"));
var query = from line in lines.Skip(1)
let split = line.Replace("\"", "").Replace("\'", "").Split(',')
select new
{
ozn = split[0],
ofu = split[1],
ozu = split[2],
ozk = split[3]
};
foreach (var tuple in query)
{
string[] ooo = new string[] { tuple.ofu, tuple.ozu, tuple.ozk };
_oznaczenia.Add(tuple.ozn, ooo);
_klu.Add(join(ooo), tuple.ozn);
}
}
public DokumentReader(string fileName)
{
Kontrakt.requires(File.Exists(fileName), "Plik SWDE nie istnieje: " + fileName);
_budowniczy = new BudowniczySwde(this);
_reader = new SwdeReader(_budowniczy);
_reader.Read(fileName);
Kontrakt.ensures(_budowniczy.CzyZbudowany, "Plik SWDE nie został prawidłowo wczytany.");
}
public void dzialkaDotychczasowa(DzialkaEwidencyjna dzialka)
{
Kontrakt.requires(_dzialkaDotychczasowa == null,
"Działce już została przypisana działka dotychczasowa " + _identyfikator);
Kontrakt.requires(dzialka.jednostkaRejestrowa() != null, "Działka dotychczasowa nie ma przypisanej jednostki rejestrowej.");
Kontrakt.requires(dzialka.countKlasouzytki() > 0, "Działka dotychczasowa nie ma żadnych użytków.");
_dzialkaDotychczasowa = dzialka;
}
public DzialkaEwidencyjna dzialkaById(IdentyfikatorDzialki id)
{
Kontrakt.requires(id != null);
Kontrakt.requires(zawieraId(id), "Rozliczenie nie zawiera działki " + id.ToString());
DzialkaEwidencyjna dzialka = _indeks[id.identyfikator()];
Kontrakt.ensures(dzialka != null);
return(dzialka);
}
void wczytajPlik(string fileName)
{
_fileName = fileName;
_doc = DocX.Load(fileName);
Kontrakt.assert(_doc.Tables.Any(), "Szablon wykazu zmian nie zawiera żadnych tabel.");
_table = _doc.Tables.First();
_templateRow = _table.Rows.Last();
wczytajNagłówek();
}
private string _operat = string.Empty; //Sygnatura dokumentu.
public PunktGraniczny(string zrodloDanych, string bladPolozenia)
{
_bladPolozenia = bladPolozenia;
_zrodloDanych = zrodloDanych;
_rodzaj = new RodzajPunktu(zrodloDanych, bladPolozenia);
Kontrakt.ensures(_zrodloDanych.Equals(zrodloDanych));
Kontrakt.ensures(_rodzaj != null);
Kontrakt.ensures(_operat.Length == 0);
}
public void dodajPodzial(DzialkaEwidencyjna dzialkaPierwotna, string uwaga)
{
//Działka powinna mieć inny numer!!!
Kontrakt.requires(przypisanaDotychczasowa(),
"Nie można dodać podziału bez przypisania działki dotychczasowej.");
Kontrakt.requires(_dzialkaDotychczasowa.Equals(dzialkaPierwotna),
"Podział działki dotyczy innej działki dotychczasowej " + _identyfikator);
_dzialkaDotychczasowa.podziel(this);
_dzialkaDotychczasowa._przyczynaPodzialu = uwaga;
}
public void dodajPunkt(PunktGraniczny punkt)
{
Kontrakt.requires(punkt != null);
int countPrzed = countPunkty();
_punkty.Add(punkt);
int countPo = countPunkty();
Kontrakt.ensures(countPrzed + 1 == countPo);
}
public DzialkaEwidencyjna(IdentyfikatorDzialki idDzialki, Powierzchnia powDzialki)
: base(powDzialki)
{
Kontrakt.requires(idDzialki != null);
Kontrakt.requires(powDzialki != null);
_identyfikator = idDzialki;
Kontrakt.ensures(_identyfikator == idDzialki);
Kontrakt.ensures(powierzchnia().Equals(powDzialki));
Kontrakt.ensures(_dzialkaDotychczasowa == null);
Kontrakt.ensures(_dzialkiPodzielone.Count == 0);
}
private bool operatowePunkty(DzialkaEwidencyjna dzialka)
{
foreach (var punkt in dzialka.punkty())
{
Kontrakt.assert(punkt.rodzaj().zPomiaru());
string operat = punkt.operat();
if (!operaty.Contains(operat))
{
return(false);
}
}
return(true);
}
public void dodajKlasouzytek(Klasouzytek klasouzytek)
{
Kontrakt.requires(klasouzytek != null);
int countPrzed = countKlasouzytki();
foreach (var uzytek in _klasouzytki)
{
Kontrakt.assert(!uzytek.Equals(klasouzytek), "W działce " + identyfikator().ToString() + " już jest klasoużytek " + klasouzytek);
}
_klasouzytki.Add(klasouzytek);
int countPo = countKlasouzytki();
Kontrakt.ensures(countPrzed + 1 == countPo);
}
private Klasouzytek parseKlasouzytek(string linia)
{
string[] pola = linia.Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
string oznaczenie = pola[0];
Powierzchnia powierzchnia = Powierzchnia.parseMetry(pola[1]);
string[] klu = _klu.map(oznaczenie);
Klasouzytek klasouzytek = new Klasouzytek(klu[0], klu[1], klu[2], powierzchnia);
string ozn = klasouzytek.oznaczenie(_klu);
Kontrakt.ensures(oznaczenie.Equals(ozn), "Odtworzenie oznaczenia nie jest możliwe: " + oznaczenie + " z " +
klasouzytek.ToString() + " = " + ozn);
return(klasouzytek);
}
/// <summary>
/// D,G5IJR,D,
/// 142307_2.0001.G00001
/// 281407_2.0005.B1
/// </summary>
/// <param name="g5ijr"></param>
/// <returns></returns>
public static JednostkaRejestrowa ParseG5(string g5ijr)
{
char[] separator = new char[] { '.' };
string[] pola = g5ijr.Split(separator);
int maxFields = 3;
int minFields = 3;
Kontrakt.assert(pola.Length >= minFields && pola.Length <= maxFields, "Nieprawidłowy format identyfikatora jednostki rejestrowej: " + g5ijr);
string numerTeryt = pola[0];
string numerObrebu = pola[1];
string numerJednostki = pola[2];
//int numer = int.Parse(numerJednostki.Replace("G", String.Empty));
return(new JednostkaRejestrowa(numerTeryt, numerObrebu, numerJednostki));
}
public IdentyfikatorDzialki(string numerObrebu, string numerDzialki)
{
Kontrakt.requires(!String.IsNullOrEmpty(numerObrebu), "Numer obrębu jest pusty.");
foreach (var c in numerObrebu)
{
Kontrakt.requires(char.IsDigit(c), "Numer obrębu nie składa się z cyfr:" + numerObrebu);
}
Kontrakt.requires(!String.IsNullOrEmpty(numerDzialki), "Numer działki jest pusty.");
Kontrakt.requires(char.IsDigit(numerDzialki[0]),
"Numer działki " + numerDzialki + " nie zaczyna się od cyfry.");
_numerObrebu = numerObrebu;
_numerDzialki = numerDzialki;
Kontrakt.ensures(_numerObrebu.Equals(numerObrebu));
Kontrakt.ensures(_numerDzialki.Equals(numerDzialki));
}
public void dodajDzialka(DzialkaEwidencyjna dzialka)
{
Kontrakt.requires(dzialka != null);
Kontrakt.requires(dzialka.countKlasouzytki() > 0, "Działka nie zawiera żadnych klasoużytków.");
Kontrakt.requires(!zawieraId(dzialka.identyfikator()), "Rozliczenie zawiera już działkę " + dzialka.identyfikator());
int dzialkiPrzed = _dzialki.Count;
_dzialki.Add(dzialka);
IdentyfikatorDzialki id = dzialka.identyfikator();
_indeks.Add(id.identyfikator(), dzialka);
int dzialkiPo = _dzialki.Count;
Kontrakt.ensures(dzialkiPrzed + 1 == dzialkiPo);
Kontrakt.ensures(zawieraId(id));
}
private static Collection <Kontrakt> Read(SqlDataReader reader)
{
Collection <Kontrakt> kontrakty = new Collection <Kontrakt>();
while (reader.Read())
{
int i = -1;
Kontrakt kontrakt = new Kontrakt();
kontrakt.id = reader.GetInt32(++i);
kontrakt.jmeno = reader.GetString(++i);
kontrakt.prijmeni = reader.GetString(++i);
kontrakt.cislo = reader.GetInt32(++i);
kontrakt.tym = reader.GetString(++i);
kontrakty.Add(kontrakt);
}
return(kontrakty);
}
private JednostkaRejestrowa(string teryt, string obreb, string numer)
{
Kontrakt.requires(!String.IsNullOrEmpty(teryt), "Numer teryt jednostki rejestrowej jest pusty.");
Kontrakt.requires(!String.IsNullOrEmpty(obreb), "Numer obrębu jednostki rejestrowej jest pusty.");
Kontrakt.requires(teryt.Length.Equals(8), "Numer teryt jednostki rejestrowej jest nieprawidłowy: " + teryt);
Kontrakt.requires(obreb.Length.Equals(4), "Numer obrębu jednostki rejestrowej jest nieprawidłowy: " + obreb);
Kontrakt.requires(!String.IsNullOrEmpty(numer), "Numer jednostki rejestrowej jest pusty.");
Kontrakt.requires(numer.StartsWith("G") || numer.StartsWith("B") || numer.StartsWith("L"),
"Numer jednostki rejestrowej nie zaczyna się od G, B lub L: " + teryt + "." + obreb + "." + numer);
Kontrakt.forAll(numer.Substring(2), char.IsDigit); //Numer jednostki rejestrowej powinien zawierać cyfry
_teryt = teryt;
_obreb = obreb;
_numer = numer;
Kontrakt.ensures(teryt.Equals(_teryt));
Kontrakt.ensures(obreb.Equals(_obreb));
Kontrakt.ensures(numer.Equals(_numer));
}
public static string nazwa(string teryt)
{
string kod = teryt.Substring(0, 2);
switch (kod)
{
case "02": return("DOLNOŚLĄSKIE");
case "04": return("KUJAWSKO-POMORSKIE");
case "06": return("LUBELSKIE");
case "08": return("LUBUSKIE");
case "10": return("ŁÓDZKIE");
case "12": return("MAŁOPOLSKIE");
case "14": return("MAZOWIECKIE");
case "16": return("OPOLSKIE");
case "18": return("PODKARPACKIE");
case "20": return("PODLASKIE");
case "22": return("POMORSKIE");
case "24": return("ŚLĄSKIE");
case "26": return("ŚWIĘTOKRZYSKIE");
case "28": return("WARMIŃSKO-MAZURSKIE");
case "30": return("WIELKOPOLSKIE");
case "32": return("ZACHODNIOPOMORSKIE");
default: break;
}
Kontrakt.fail("Tery zawiera nierozpoznany kod województwa: " + teryt);
return(null);
}
private void writeDzialka(DzialkaEwidencyjna dzialka)
{
string id = dzialka.identyfikator().ToString();
RodzajDzialki rodzaj = rozliczenie().rodzaj;
bool nieznany = rodzaj.nieznany(dzialka);
bool wektoryzacja = rodzaj.niepomierzona(dzialka);
bool pomierzona = rodzaj.pomierzona(dzialka);
var operaty = from pkt in dzialka.punkty()
select "[" +
pkt.zrodloDanych() + ", " +
pkt.bladPolozenia() + ", " +
pkt.operat() + "]";
string joinOperaty = string.Join(" ", operaty);
if (nieznany)
{
_writer.WriteLine("{0,-16}{1,-16}{2}", id, "nieznany", joinOperaty);
}
if (wektoryzacja)
{
_writer.WriteLine("{0,-16}{1,-16}{2}", id, "wektoryzacja", joinOperaty);
}
if (pomierzona)
{
_writer.WriteLine("{0,-16}{1,-16}{2}", id, "pomiar", joinOperaty);
}
int count = 0;
if (nieznany)
{
count++;
}
if (wektoryzacja)
{
count++;
}
if (pomierzona)
{
count++;
}
Kontrakt.ensures(count == 1, "Konflikt rodzaju działki: " + id);
}
protected bool?pomierzonePunkty(DzialkaEwidencyjna dzialka)
{
List <PunktGraniczny> nieznane = new List <PunktGraniczny>();
List <PunktGraniczny> operatowe = new List <PunktGraniczny>();
List <PunktGraniczny> wektoryzacja = new List <PunktGraniczny>();
int innePunkty = 0;
foreach (var punkt in dzialka.punkty())
{
RodzajPunktu rodzaj = punkt.rodzaj();
if (rodzaj.nieznany())
{
nieznane.Add(punkt);
}
else if (rodzaj.zWektoryzacji())
{
wektoryzacja.Add(punkt);
}
else if (rodzaj.zPomiaru())
{
operatowe.Add(punkt);
}
else
{
innePunkty++;
}
}
Kontrakt.assert(innePunkty == 0);
if (nieznane.Count > 0)
{
return(null);
}
if (wektoryzacja.Count > 0)
{
return(false);
}
if (operatowe.Count > 0)
{
return(true);
}
return(null);
}
public static Powierzchnia parseMetry(string s)
{
Kontrakt.requires(!String.IsNullOrEmpty(s), "Powierzchnia jest pusta.");
Powierzchnia pow = null;
try
{
pow = new Powierzchnia(long.Parse(s));
}
catch (FormatException)
{
Kontrakt.fail("Napis " + s + " nie reprezentuje powierzchni w m^2.");
}
catch (OverflowException)
{
Kontrakt.fail("Napis " + s + " reprezentuje powierzchnię poza zakresem dopuszczalnych wartości.");
}
Kontrakt.ensures(pow != null);
return(pow);
}
