2026-07-10 AVE: v1 6.8.0.20 Timsession.allinstances.login->first.checkFeature('fcAuslagen') TimSession.allInstances->first.checkFeature('fcPhasen') ClassSettings.allInstances->select(klasse.containsType(ConfigSetCustomClass26))->reject(eintragid='ClasssettingsConfigsetcustomclass26Lizenzprodukt')->size = 0 cc26CustomfieldManufacturer ConfigSetCustomClass26 cc26_licManufacturer Manufacturer String false 20 None cc26CustomfieldProductName ConfigSetCustomClass26 cc26_licProductname Name String false 10 None AdditionalField_LicAccountinginterval InvoicePeriod.Monthly, InvoicePeriod.Quarterly, InvoicePeriod.SemiAnnual, InvoicePeriod.Annual Outlaytype,OutlaytypePhaseLink lic_accountingInterval Invoice period Multistring true 0 None AdditionalField_LicAmount OutlaytypePhaseLink lic_amount Number of licenses or service contracts Currency true 0 None AdditionalField_LicCalcInclDiscount Outlaytype lic_calcInclDiscount Consider discount Boolean true 0 None AdditionalField_LicCalcPrice OutlaytypePhaseLink lic_calcPrice Calculate price from license Boolean true 0 None AdditionalField_LicCancellationdate OutlaytypePhaseLink lic_cancellationDate Cancelation date Date true 0 None CustomfieldLicInvoicingendofperiod "In advance","In arrears" Outlaytype,OutlaytypePhaseLink lic_charge_type Service contract charge type Multistring true 0 None AdditionalField_LicDescription Outlaytype lic_description Description UnicodeText true 0 None AdditionalField_LicDiscount OutlaytypePhaseLink lic_discount Discount Currency true 0 None AdditionalField_LicDiscountpercentage OutlaytypePhaseLink lic_discountPercentage Discount percentage Currency true 0 None AdditionalField_LicEnddate OutlaytypePhaseLink lic_endDate Service contract end date Date true 0 None CustomfieldKindOfPurchaseType Kind of outlay type: standard outlay, license sale or service contract. "", "License sale", "Service contract" Outlaytype lic_kindOfOutlayType Kind of outlay type Multistring true 0 None CustomfieldLicNextinvoicingdate OutlaytypePhaseLink lic_nextInvoicingDate Next invoicing date Date true 0 None AdditionalField_LicNoticeperiod OutlaytypePhaseLink,Outlaytype lic_noticePeriod Notice period String true 0 None AdditionalField_LicPercentageOfSoldLicenses Percentage of the license price used as the base for the maintenance service contract. Outlaytype lic_percentageOfSoldLicenses Percentage of sold licenses Currency true 0 None AdditionalField_LicProduct ConfigSetCustomClass26.allinstances->orderby(zusatzfeld('cc26_licProductname')) Outlaytype lic_product License product Object true 0 Object AdditionalField_LicStartdate OutlaytypePhaseLink lic_startDate Start date of service contract Date true 0 None AdditionalField_LicSupplier OutlaytypePhaseLink,Outlaytype lic_supplier Supplier Object true 0 Address BenutzerGruppeRootInvoicing Folder access invoicing BenutzerGruppeRootSales Folder access sales ReportInvoiceLicensesAndServiceContracts vtcSaveReportOnInvoice false true %dokpfad%\%nummer% PDF true outlays->select(hastag('servicecontract') or hastag('license'))->size > 0 false false 0 Invoice licenses and service contracts 0 true false Invoice true true false InvoiceLicenses.docx DE 0 UEsDBBQABgAIAAAAIQCw29Ve2AEAAE0LAAATAAgCW0NvbnRlbnRfVHlwZXNdLnhtbCCiBAIooAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADElk1rGzEQhu+F/IdF1+CVk0Mpxesc2gZyaQN1oVdZmrVFVx9I4yT+9539pJRNdtON6MWwluZ5nx3LYjY3T6bKHiBE7WzBrvI1y8BKp7Q9FOzH7nb1gWURhVWichYKdobIbrYX7za7s4eYUbWNBTsi+o+cR3kEI2LuPFhaKV0wAukxHLgX8pc4AL9er99z6SyCxRXWDLbdfIZSnCrMvjzR161JgCqy7FO7sc4qmPC+0lIgrfMHq/5KWXUJOVU2e+JR+3hJGxgfTahXng/o6r5Ra4JWkN2LgF+FoV380QXFlZMnQ5X5y5gRT1eWWsJQX9N8cBJipJ6bKh9WjNC29x/zkKeIzvw0FdcI5j44H68W6wzQmgcBNQw9fLYX9mT2EMj+7ZsxoCclIp4riG9v0HKn4wGRClIIdORJhUfYf09m8Qd8UqR0Dq3DFL/GgJ6UAKsSOfTkSQXpTE1IoNCTZys0954ClU6lT5itdKcSNobgs44phOVX5ughhTCZfwShkuS34Jn51/8tv21TgvyZ/S8pcif2FaQw6NCTEkgTE7Sfy09Cg3kpknY2cwL9CcM/vHY/YtXVKz9rQBgSCb34/aC7Y16b3Q41i+NbzEg4b4bh7W8AAAD//wMAUEsDBBQABgAIAAAAIQCZVX4F/gAAAOECAAALAAgCX3JlbHMvLnJlbHMgogQCKKAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArJJNSwMxEIbvgv8hzL072yoi0t1eROhNZP0BQzL7gZsPkqm2/94oii7UtYceM3nnyTND1pu9HdUrxzR4V8GyKEGx094MrqvguXlY3IJKQs7Q6B1XcOAEm/ryYv3EI0luSv0QksoUlyroRcIdYtI9W0qFD+zyTeujJcnH2GEg/UId46osbzD+ZkA9YaqtqSBuzRWo5hD4FLZv20Hzvdc7y06OPIG8F3aGzSLE3B9lyNOohmLHUoHx+jGXE1IIRUYDHjdanW7097RoWciQEGofed7nIzEntDzniqaJH5s3Hw2ar/KczfU5bfQuibf/rOcz862Ek49ZvwMAAP//AwBQSwMEFAAGAAgAAAAhAJcpbTlkPQAAlasCABEAAAB3b3JkL2RvY3VtZW50LnhtbOw9a4+bypLfV9r/YM2n3dXmDO/H6CZXmMdJtMnZaJJ77peVjrCNx76xwQKcmeTXb79gADdQYGzsySTS2MamurreVV3d/O3vT9vN5HsQJ+sofHsj/ibcTIJwHi3W4cPbm3989d4YN5Mk9cOFv4nC4O3NjyC5+fu7f/+3vz3eLaL5fhuE6QSBCJO7x9387c0qTXd3t7fJfBVs/eS37XoeR0m0TH+bR9vbaLlcz4Pbxyhe3EqCKJB3uziaB0mCxrP98Luf3DBw8ycYtEXsP6KbMUDldr7y4zR4eoYhdgai3pq3xiEgqQcgNENJPAQldwal3WKsDgApvQAhrA4gqf0gcSan9YMkHULS+0GSDyEZ/SAdiNP2UMCjXRCiL5dRvPVT9DF+uN368bf97g0CvPPT9Wy9Wac/EExBy8D46/BbD4zQXTmErbzoDEG/3UaLYCMvMijR25t9HN6x+9/k92PU7+j97CW/I9jAhkXDmbfBU7pJ0uzeGEI7ervDDAuh2m0cbBAdozBZrXe5ddj2hYa+XGVAvjcR4Pt2k/3ucScCVa3OtDmUDc8AIegz3m03FPNmiKIA4CYGkd8BQaE8ZobJFknw88C9SFMgrgg0PhkA6QCANg+AziKDYTAYt/Nn7cZw1kC1yuBQrmA462fCikAbWEWmAGCx7wRCkjM88Au+vQArWaSLVTdwGY9u8b1+6q/8JFcaCnEJNAQZRKUAkQrYJprn9gzDDLoRTc0B/tgWeLh7OE5Rf4+j/e4Z2vo4aB+eTfYjDp46wGIKXzRCyXHIfFn5O2TJt/O7Dw9hFPuzDcIIqe8EaeCEcAD/RYKMX8jb4Ilcx/LD3iw3+M1iP8Em8eYdCgJn0eIHfk1nG/byOWZv/jl5xFbG1BT1Br1Nf+zQgIsn/+aW/eCj/yPap/lXy/VTsMi/tIPN5pNPYG2CJf4VgiVwAMXrh1Xt17dVWHjYKPqGfvfdRzIsoH/4puU6TtL7KIOx8YufyJd2tNlvw8L3pQth9H6KguT805/ZpxyHnCy/x+sFfvuAXhEMirloGjKdTumypMki57Jqci6apsK5Kko677KiEtSqVwXuaLrEB8zD2HiecTbRNEZfoQRjcY/prcqaZ04xlcilzzG+aGqy6rrooqjc7fzY/4BoJ0umapmmRq+iMCzFV3X2LwPwldxviaqle0Qg05hSGmNlLdMAD05Yzab2mF0kyHLkMn4fMIkit+k5DxngdE7/Zp+YmKuaRpCqgMNofNn5YQaOMeO7tVk/5BdnUZpG22wcBnlXooaqmYKN5tlMjXoK24LkeJiW9KITLP39Jj38+Wd8SbZl0aH6vWPIfEl/bIIM3y8kIYwX0SoMrFnipz+ZKtIfz8iHffZrbHw2Af3Fxg8fsuuL4I39nk2a3HmbDzdDKorjaDRQjDmB/TLVLH+LqDsLF5+QBgYxBYqMHw7w7hHsoHgH43gufiVKDIAv4tU7f5YE4SKICefoV1WU3HDREaG4RO3/obD8+GewRoY/pEAo0snP7FcSU+jkp53k15ji9plaNoNgGcRBOMfY5FPIZnlKymK3d5fs/Dni9y4OkiD+Hty8++9JA6GLvGczPwvv//IXCMEkAMkAFLELlgEC8QpkgPmn88jAbvMTxH8oUhfMfzKF8fgPZT9ztedhfxSnIPZDkbpg9pMp0Flij82CFkIPfmgk6pICCI0Ypp1DI8GSLVs3cJLRKzRyHNmxcPB5ptAoIzAmXpnQVQlWucLC8K2BimXwQzixV378APNI0FGGFclWMSNodREzSVJIgNsiZswAdxczW1BcWWNZSi5m6tRUNM1sF7M8xzkQM8kRHVcaQMzaJUpjvKZysoujfwXf0k2wToERbHY/dLYdxWcQwSE4cgQHv9CJg9EvC4ApuIJiYEadLyElSGeCzhX7jonnpwDZhewi8qlYOBrlHuXhuiVlxGg0r5Iqqo7NFfHSN0TE2aWCiGNPvyYeaRYsoxjNhuR8PqYPfl80pLEXhSmWDD+Zr9dvb76ut0Ey+SN4nNxHWz/E9wUoRbSStc/9cmWFCf+2eXJ4uSqcjJgl4WTXmE99Hrwhza3TUr2kpXEwX4X78CGhaQbmAEhXi1A66OAVU7bWJBBSZNQqEeSaJwuKj6kJrCq17qqSYslYfXvFTPXObLCYKVMTmPM/cYwpq54mKQrECF5ZjEkKto/dY8yvwSbYraIQFmNCRzlzjEnQ4oQKY8WYsutMTdXG0eSlq2W9RLHFCSYneYZcdVoVWSgEjOk7JFvLKARJVjZaLbRzh58EIY5M4RdKkxzXw+C/IfwUTcuTplJLmnsV4Wc/5dBN20MuSwYoRzNRIQkYu9RTOS7CZ0nO1NVkuyIwkmSbmj212ulV77MGo1euS918lpjlAlyEa8BiW+Ju/fUGZFbAQ5zZY1G8Lshl6bagqbKIXUtBykRjaguS7V2UVjYIFH9ljuNFsnwBh/dWvPY3HE7mBdJM7AK42IEROZc7oxidwJ8JrmbKsuH8uv5MEFFMprcQ4NWf5cGxrbkSbmcp+zNPQ1OjA1+tP+MvCrf7s+1jkm78WQA0LtBhzu3TCgvKF+HTNEOyDVHB9cqiT0Py7UkmbsEZXzOfedXZIwHkMVukbh2nKowhsBGGvwrez83VU6BRNiteuk42C4vdg7o/yZJElIO3ZDMv2f0p7lRXRBwivro/yPqj7qDUzagE2rJko2xOBdDrgt0fvymi3f1lWztgNgc6yrm9X+d+ilMXIW3DQulbpfFWdZG90izSyn3p3u9Q9NodTYt7W24WuKVikr/7Sog/Cx7WRCQy2Tt6oHWYpPFXRPSaxR3vw0f3D+uTO5n8339NPrn3v7ve/95/sr6SVZ/85gERqpl5EmB5SUkn0ZFj4Yb5z3EULSvqfc8WPn9bRPOnio6falpBSLYgcNSR+E6CWD52N4fvCKKkii21/Rfs8BUPRdCyhNf0Xx0+JAuZ6pYhypipRXoJjqcZ+jMdLtbhX4QzU9WpLXpipWig27og6OYzxa7ImQ1qlAQFWyW8N/kXNUqi5xme6UEaIV6NEvFipiV5XlWfwPR6NUpY6zzJ1Q29Ret+WaMkiZrkib/wSrfsqIJkVTOwV6NURy9FN1Tb1CqlkVej1K0eJxk2Ci17W/axhO5YayNrli45Tsu8L93adE8ubNN1vd4qcyS32dyLG5CC8M3v01bfMpaJkW1XEqagTUbXQa8TWxNFc4WprTJdOzu9/jXPcCXHQ5QscHciHmtiNFt3HbOt25qaGMOTbOFFmBhFM1VXbsstr0hlZFPnHUBSpRfbT9fdAXuyrEjSWCpzHu1QZV3HvYdF02oqjisYoBoERzuqB3ao2WaPkQ/sMDVBlMz+DiOjVD9ulsOpWRAn81W8XqbEdGRsbFiS428KZUgROr77EH6P1vNgEka/ETJQMalCLSzAtcJkDOvW26bwlt7yxv7yNKtLb4U9po1zPW4juljdNckhZrhH9wKbJ1rBnZ2OdVsum0wp7/CdqvKxmfap+qq24vSPbnsqX60EcPbiNRpaLAbPZwtUxKLK+IO1r1bQwMMKcrTbBhyqG7UV9ToBLG/wO5Y+R547IvJ3O/Xg08I/2DXT5fb9FsbmGnyPNCjH9ETUbczCL3RygFiDE4mrgqepZptXprFG4VAOTqyxut/jA/SCJ3+e4vvY9IDBR82heFX7l+1C6J7eI/PnTS1MkhcbS3qKLkyr61maZmtqWyWQ8lc2FNM26vhL6a9lEcLI/BRVR9dNt7IWLNnIjRoy7iBvodVU0US7fzTZhZ/809tI38Pz8W1/RKnjUlrUWdHMfFSsEpsJFCts/rwonkT7eILtOApYk0lM/GqwAFlHMB5jO0EKscYJdicbLObl8VoiLdI5rz8H8TpasCOHarnN703vwe3nEe0oXNyt/OSvHf0MYzcUkdHZXeiab6Arv9O6H12J1hKqVkgJNhK1chVGaVW0jkd5nfzluDCuQ8k0OtdLh6/Vcp3f69qDhIt9jI9kSVfBhGoRjJzQ8UcnZ6H5dgByHVcnkPgFkh5c+w7cPA8ecXQ+NVVqehDoDZQl/FpLH/O5TmAsgY44OksKRZ+zqU4WbhToxRZDajnIr2H04OA8QpOPQ2QOYYyEDjw6I5uKJ2e3gfxaxCEaM8iM8yPuZkEaB8sljHFQFEZnXKFKMoSAl6O62yHzckkVLEt0Qc3v15SXC7o+1Wyn95kk8lTQ1Of8/fx5uVTOy7Ok/NDOiuygnTrFlflpMptgFzE8Ll0H4zG29lJEa7S3O9n6p+syN11vK8/IbPLH87s4Zq+UHYzK6Cwnd7e5QJmfi/agbDl5I8/dwch0SOTAuIxO2qZDyU+lTbUc5Ke/PTgITeTAI47Op6aEuweBoImczM90+5grYCIHHnF0ljTl1qd2RAV6tSRyMj8x7sHBjokceODRGdmUkZ/dBvLT30M0ZpAZ90rkwCiMzrimDHwoxt2BOcfPf/tFdiykg1fiwaOPzrTWHgVOsYolUT2zaNFVjKniVs4l4mfRjqCJIj1eHdy9kMVQwybV6XwaxSiBSyhNcE6d/YQ9jGSC+cJ6mJnckkbbebSJ0GT8fRplmBVhdd+8KHuSDHtSCJcnoi64xtBbXL5tAnqEBEyvsKhlr4ci13cbsKMptkIO6G8vz+iK5sl1gkU5Dy3PaKZCkk9YR3WJ+Wm0G0aK0vnBYybpcToVpArPmeR8T6AyQN27dTRV1L2DE1dsQXYlyMl2Z+zWqSkhlKtIn/19Ml9lh3vU+Zms4TQX2dJkoIhhl/Jxv90lwGY38Khj+xeKaE1QMFRPI/hZWiw4P55XBfEgkcGOfqjgUTJjuieJFi0IQ0epHohYhieputExkkFhpw9LF8CkGl3Asr0ATL1zb1JrriVdgOyxe+nmWvVMb2oIYx3cevTetgY1ZwJ1vJoztd50URzo4KMrDrmbozj4hc6/ZG+4QuDgFl22bpTH98jUyYICOhKZE4b12yeI7+8ZvikaOY0fuIcUnAcQGzOiSahVfM1xBVeSKzv0VFkxdMsDdOHmPB8if3je05XV6I8O4yhueRj33k8+r/wkP/OQdwfhVX7Hx2CdpPhRVWmUZuEfp9LXspSoZJVT6KywcSGYwuwMB/zoJqVcg+0w8SPjuuIDATuEcLlo0BgOv0UBOKwwno/JVY5LYkr3bW0i7XOH7Sl9AQZRVxXVII956BUJndYgnjJQ6rOhz10uwY8J5peuL1BHCqVrmI6IBqh6yLC6fh2RTMfzzF9RR7JKfhcd8QKgE695otzlKcgQWxl5yYLmWZqlOrCWuitMFs6knrql2VOJRO/FnXWSbajiFO8j7K2egiOapEjQpJ7dVI0bgldqrzgWo7SpU0w1K4F2UcxdRS15QtsFHjhcz7GFsqKAxdjKT3FvIlnbDE4b/qvVWuWAmOE0YWCZ4eV4J0HdfRpa3DvmSMcwZnSh71xX7po2nck1yLo4NW0Xr1AWXIMiTj1ZJ8da9XYNlqxN5RzC+eu8KmMwlRegCDeu0Qylefvlo39gN2p0JJvENeoIubuLjnRNm86lI/iMt4Pz1RVLETVZI/Hj1eoI5yFY7VHNwG4jCqPYhx0LleN7jerQ+pStwyqywubL+QbeZcVrhlEk0XVkG6vD1TfDkPlyqiIodUT/yWirYBvY9OrMn397iKN9uKCI4K++rPxFgG/IDcKF9c7osqp5bmUHlqZKmDHP7G6XgAMDBCqvDGRrsvb9LrbhC9sfBbMO/A0Cl7e4ShE9sJ/jtL2oNUcW9mp7KS+OHXuMxrtkFT3+VedueuO5KSEJEy0okUYXrcIiW8nL1JrkUzS8vHyTLBiipMrWWA96OmVMWHP0Zk89ewxiTB2YlkGHHl3L6lZN8QudfT6HTnGZoBqaImj4pxcdl42uf7JsecpUYMcs520qmjnFz1xt1z/DVNQ+j8PgVafp3PLq9L0/81OmkpzAnQUpterHX/Rh+FLFug8W+3m6Bu6bzCGeQIHaNaV8fgPBv/82brW8DkApPSXtd81U1fgd0SWqVgDWBi8pOcgr3sXRTxD928c+N1MoRjysSzSr1mc5NNtwu9J5rCM2rcq6z4iGaOg6XVE5TVQFurbid3a6FqrCDXTl7zfnyyKjUIMwdhDE1oHPTjDQSW8aP68rEWwXxHOM5APwCI12mGenRVNSWJxrjfn8j4Z5l6jJT2VK1OwgU63Qzk7Hpq3epVn+Z43ZKsyuWn4HcwPKDH7Ey7cFDUaAZLIx+VWHbvT20c/OvM7tiF3T1/GLeZrjmm61GeMlZI4a9Cj91syxpzhfy1H+FFGOlOMXSoJ8Dt3SRw+lRKZ5TWX9pn7HX6CMZGmCqaqV3RZnMwYD6f1gz4L4I0gnywBY7gcPO7q617VH1urTETXZX1ufZE1xPc/EBaBe+mR7qnJEI3KTc521SxBA1VhGXJF5hna30bCKFUu0oT9fUZ8LUz8oKhD1o+ieVAkJuifwueJUlG3Lajlw43UpnSAxvsPVNW2qVpfSFU+1PYX0mbdIwJB1Y/qkxbwk9mWHsscw21TM+ps5RTEW5daZCB1QtnOfdkF42GZKv4R533yYjpo+SJpIBy/j3b+qrJdLk5QPkKqyDqvkFQG2VJUTcOGlfeyzM6XpeMrhSiY6oBoIL0vrpOGwwvuWsrTOHFENYy6uskgxaqUrrBRVolCDNHeQ5IurQlGMWgnGLzccVZZuh3l2WjSd2zdgWVoHrHt2kKlWaGenY9NB9h3L0np7Cf9IG8uP7fm2II9YimcdbRL8XY2jozU96BGX7cicnZd1ucTz3+ES+l85WLdU2zCNyuaUl1AqN/g9AUccQkT0raNmgbEYu4JGEeUoHH6hhMjn0C4NxXqR6KmuJ7S08b32W91ooio6Rka+vN9KNV3Vo60dJ1XFblrHC/SJFakG+pRsHAfLJLhWffnrwj3Ul2XisJwbPOzo+pr70UGodFwwY/Az5X4N7lRuBmlsr95/NHp/UR9wDF7QTt2cppckdOX6w8Dyha1L7nZq7frVdSOIU88WHbH3yS0XHGJBdwO1KytRK7BqXMsuJIooR7rxC516v6BKtFz8YPkWmXoNqm4UyXEtS6/kN7Jr2LZsAZrYxw+qytVTa59sUPZRG1YZbM2gVmUH23rirJPZPq5GVeBZ47tqD+HojRSeMzDQu5aNMBTRwUh0ZKA3WP9ZQZZJqOezD2AfcC2daBRRjg+oNbJXF+HosuwYplvZKfQiIpzB+q46y/e1tF5RRDnyjV/o5EsxDgtHSgKkTvWpK3cPZ2abz7H7xN5+RM4wQ19QyL7Ru+U6TtL76BGfSzfBM2Sfnr+0o81+Gxa+zy7QzoHo/dQPF/mnP+mnbG28iEDG6b6hlappPLVtO72I1q6zKVVubjEJeSNbze3Hm4zHu9V6EaAffWuyH5o5lV1bbnluTFl6DkxFQS6GC77Km+E+rn8G4c+G4IuZ5DprYmbFYCh22E6At/byoI9tHChOGd5d5n1cnGJyWmcgIUnGYfdpd7dh72HEP2GvTm/iH7bwDEj8kq2vtWqipPNimePshazplukakJMButiLE8YRJmNkJ3n0w5/+CnZ4Bg/+6OJH7u4kLIrU4WzX42RINEVPl8l41yJDfU4SS9J9MP+GdBj4uFneIKMLUt2xXg1Wh65FtQgSw+plxVKaKdhm23LrRcl1n1OruqZTvEFGl+tTVYdlT/Bcw32tDrfuZZnKpuFoVSfgKZbsHFe48GRJ0nBB5LTVYbNcHf4zwufy74MkCaz98j6Yr8J9yDqsOelKywN0zD5PdYEc79oF3uK7jzQm+QpW9Gpdlz/u6LrPr+r2I9KRuVK1ktom7l3Y9yyUA8tF9wO8+dj/PwAAAP//7F3pcttIkn4Vhn7NbOx24z4UY0XgnHbMuMctqXt2NzbCAZKQiDYFsEFIsv1r3mHfcJ9k64QAsIooHCRIWT0xpggQdWR+eVRmVmH2fPkUrd9dxOl//NW9+PHqLz8+X+Yf86u/PF8WV9st/Frgi/BSPgP/3ybL63cXkqT4sh8oF+g6fmIdpfezfQ3GAu3RSx9zeNE2VD0IOnXiPN5dx4tV+pjee1m6HHkKl09Zvl2sHrfbeVzk0X2j+UX28BCnxTVoJg7SJWgqWb67sE3YTL/55jfF13VMx/Q33H6Uf4uTxSpOcbvbb/S+ItEr3ra8puBrLXOjQ4/v4jxOF7DLl7Hj+YF/N+jfYoGoQf4ltFn8EzzyDPozJQ1Oq/i6id9dLL9EuPv7PFnebKKUDkHHl4vFhwiTPr4rcAO6yXg8T+5X/PtoTKShJ2ed3JfdzLOiyB7K3+CxbmbPsna5ifLoPZiiYoeyH2rOBbpaxF8KeNUk/5UcamMavejHd9Hjutj9+ccG5jZ4ML8v6FjRHMl0BfAI2VHnHYTdDUAHJBRintUAXm+p6gV70d4nxzgaKAPj8AMTQEB0ddU0CYYoslTHVA0bicMeZN2i51VTM0IVkaWgZM9/igns0YxkAwkNGhUVOqYIGrYmdxFBN8uXcb6FX7C80F9sk/R+HcOmtt8AldEfm2gBGpXg34tsnYHBOwb8H+pwFT/EHr46jxaf7/PsMV3iscBbN6toGcMHSoGsdH0CqsCQDDPQLDi5XqogMHU30Hurgm5SP8+yzw9R/rkm8TbsIo0eAEHm6TL48nn9uE2eMOHoAxURJRDgKRBZIsLWkGEyzy4a5DYrovUs/rJY/zD7zbkV0iDi3U+tQshId9yMvuSafXlYU1Hb5PE2zp/ii6vZHqrV2SaPxbYKiKA7dbmKtp8gEwX5JzqO6fmHRsqwAVwl29XPeVOyRMlKnqsHftBbyXqhrmlqbyW7z9+aMxUtX8wI5hrwJgPktAvlZh0n22K7AXKdguk/JMXD87YQFCnRPkVECo5LTLAEJKj83RAvivrSVS/KVGzXNyD2j+pFaYYsIuCEH3Upyzbfq3Sbli3ZCnCpp1lNDXehZAnpltKH+vDPm1tMNb4e0Jgy2WOdJe4ZiXY5vWVFI6XTGUyioZ4RscfCYIHNQu3MDYb15nVUfBPkNR3z6fOaqtbT4DXSkWOw6i7PHgR5Rfs8KbZQY4GHc0QONCOfvTnQIe4k3uv0jOkeXVUVlkFvOiUqvvzmlGCnRPd1zZfc8CycEr40jRbOJW5N8GVzyVh5dFEQV5BJqaBcnktAmIy0k1z2jwZ8x3Ip274thSoMWr6y1Iss2WMJa4fYgGif0wsYGilDwOAHnnc5CT73GSkXXXUD07GhCLylXM7CNJuAZZrTO/s6ecpFlhFjynjBzeO8gLkOTDlGzoUI6e4dGHlAt7hKRR4tro/TMfP4Lsvj2TKPniF2ZtFilcRP8SxaPkVAWptrXo7aER7V5GoHj7T0c4ZSceDqSCaTGc7NCuzKLM2WXBDkoehYpuchepxhOri6+S1T01M3a7JmeHbYUr/A182nk6mRiWZtwLs9U4NE6CnLo/m3x3tSBRNvt81SNp5UiXZ77GQNHhhDiOAHnno55nbvuwqZwPT8EIXQz8X/Otb6a782gQkTVmfRY5GdqnrwTRlyscFrWdUNWXlxybj40VzTc9zu6oHthSEVX3phv9GCNUr5HWdLJuLD1xnssLtla7qDV1PFldPNUWptcWQjK6AI9kXsq1MV83XYrEGyUkuoNdizj8R/Enan2GHfWmPN7pG31OiAaP4n8XU3p2fZVDzJnIivlcjyPpqxQ3KVkRdXSbpYPy6BshKv2yqbnWbulegdZedQV51GVrpjgx2TmVTmK8GX/eLyZ454V+fHTrJ1Vx1c2tOptsh1TabZIr0j6XtaLCue2U3Fd3fx5yJ56lS7w5kJsYOTYAE/i8f942uJdL86T0tSFUV2NehTvbY4ucIOHg3Zo9BPNkXHMXkABI+UIbLwg6umSb2QwLKuXLVX98gEugVlcT8Az2NZ1yb/r057KKal6bILV1r9tIepefrLxZ4h9nk75kXUBTtOSYbYrTuoFlAcXFBDiHY9bjCnv56oBEpHI9iAZaBSr6t8D5YVUD2Py0/h1aLCKaDs23FlRmhRCVdNHayP6GhOBVu1ok4+kTmVi32J3GMpKjyEU6Hs3hLKvoQTWMgpNCQ80RrguzPLsqNJmir1Ln45neyKwo4BCGZXBOVYtI9jp1LwwPDoa9IDP/A8yzG3L9Cq+HA9W7OMcypl6S3cpyieUmiqnuX3Fc+Ba+5NDcZA3NJllC8/r+Mk/fyYl3t6CSsHu9WjFWo76/Usesge02I7S1JB2R63YHs8W1wLog+mzdA46Gjlv89RvMofU8FyeuF+j82dkyjSPUPNZpq+48py/3jAyWm2Ue2uovmKqxot+5Ox3fVAs6GBZjfY7toGCvC2oZPmrbsbNDVwTGMygzYZP6F35Lrmq+OnpqiW4ltTFc9PJ5+2p3uO0jLv8+OnqcuBoQRTqeUu/NznpYy27yEnx7ht7/PH7fYuyx9i0bXi2eyDwCPF0xlVSDTDtG1Ne3VCoqgBWJ5qvUtSz1XpmaEUGk6bz3aGRkxWHVsxzuG4iFH5qaqm4QWG99r4KfmGYevqVJUKIxkxlV2o08OIbfLs9/hzARY3RZyLWS/hzie3XnikB7Besmr6vim1oOj8pMMIfdu37amOGh1b25lAibkvw+bzU3c93VKdlv3358dP3XAc1fVFjjLbT6sdftZ/PqX1CjVTcpvWyw4Cx3aEUhNnxU9L9WVFacinBpwUQ9dQpK+kVeDrDt5zUKWVrzoaRPkOP+s/R/w0PcMhOZu9kbFslcbOfBsV34hdYHL91xu2jWOWYqgowfNSirENfr3GjfNNIjEVJWB2rFJx9TH6Gs3Xgnuj2hsc2cwJ2LPydy0zHRjJV9nbwmq0/Jyly6RIsvQWoFCQoq3NHp+ilX1mB6Vo63FoxVWWCpKRtjUNxerHpe0hzmWTOljec9Q155n3rvPzznN8qlYPSyuuknkkSkLGKWtHJGG9hKYDvgQo6L73OhCwehpYcTV/7wnSj13sQMzLAYjaYk720Lpj9YNqKS46+pVpNquBgSDQtVCD3sircjFkydc8320s/GXdcgBtXvwJLq0aFysuRv1Op+Rb3cWAfKxzfRfYNGNfxWKYwaT/82W0XSTJLdyV8e7iIUmz/Ccn3SZwYCv4B/POYou2cdQu72KVEL0Fq6gYkyXZBx1omn3Ms+yu/6CRF3b0YfcaKq5w3X7aHTBPobHwIqC7DjXn5ox7UIGrEetFIyfJQBFrKKTNJT000CsHqhqKXqwuGGVd1ly0AGrV5tVatvn6Yx58IX/+HSxl6KwkzUGq7i7Jt8V1BhQ3WtKsI/Lt5aaXrR8f0sp9egEf25P95AIdWH77DX+jW2yqAxhqWWTbQtWaDcvCsyAADMky/gCWbvvMiRkGluE0zQm4ojueU49AMJml6IahwKzCrjmp/RyZExIKQKPAg0mQiK8A3JL0HkxRo4u6k0L8i0Fjr4bRyh6vhj/9tP4MfHBJsSWTOLHsZ+ov2lhF2/fAO8YPcK2mRiO7ByfRYGM0hQXtNVBC+fMz99iGCi+pmNh5nRYUT5VFj7o00R2bpwnMeLP4I19kS8FwWDmbGVHFNf38HTCdt6uVa09NQBmGPW2u1EgtSPeFmqKrrmuTyPfe2H7Dsu4aUdQ66aRLjPdYcG4aSrbvx9g0pBLUsm6RsmHWLVr1AtyrXcKbvunoEgq3txFe8oCrKJ5UIT/ncuNv2eYOyNE6xiMvojku2Y3m9BewaBe2vMm2MPtjUurRn2J/CNXuvoOnbNGILIud7y5uk4d4O/s5fp5dZw/Ae6Ds3L3DkqxmlnYbL4qPpfoQJM8NeKgRQrnLsiLOqwJKJAwT8mKWIy7m75f04MdVHC1ZTyD/u/p74h1u7m+gKoE+sQz8LDRv6EhbGqmghkc5ELnd3AMXGLaYbcAyQkI54QqBUcQES/PLd8ill294dABBCl4UoOmVX+8fC/SVaK9FtoYMImsj+BsMhaRYxx/v0d/LbPFXoGNgP0kaf0yKxQoWJVJMYzY0ZakJcsV2Lddpe6kN4qLrSJ7JTCrV7yAXnVyqQPwI2Gvxr1EQ78VX/qUt1aSx8xi6LtlObfNja/UF6g05WttV9vxp+5xst38IlmGUo6gSsbPt7UzogxZs4DlVjWypg9FKl/xRhkJxnrBhYOFKPPqaPUJ+UTn/Ei/Lm168Xu/scUCyxt/isHsbW4dKW80AAPgPiXMZAEBf9wQAyvsiAYBSsVfIAqUe/gk9DNAGHjnwz4imql2WTcqq2mVFKZ3bSoP1oEpD3jH4Dd1Qaal3GSI3/UCxHaGgihloioyFh+NOoYmwuMCuwwx81Q4QPjrqLzwf2ZJk9rHNDKVWGTy129F97OZx9NlFJxhjOQE6G24NB1oIXSQsje6q+p0IyMvqbVeH8fUSO8loeqqh72xzfb58pFAlG4ZqEopwGqfAMMXLj3QyWIKugC+B7gjqKdFRiSgvPHIxHbR3flwNtO9tUL0oyQlm/rtwkk5jnxDQbzAl8z5Fy1z8oFjhMZwGE/edUTARE9kZ06FM3KwF39El3P9pMLD+QqjDMVCcf+wtwEP5l+WCtTOc/omZ6si/emywnYsCDOv8oijkgMx2fK7uBd2mYdle2+45vqH3fdV3mKtxMUPfJVwCsUFpCanUZs/ZG5vJiDntQjC9T2feKsrvRZW7aD/j6gYBVHXfQQ391xFQpauaoZohcWi7o4of4xkNVSIAqp8K26PWv2yBOb2O0BgJFB23pO3nTzWg6juqAo9LOdxyBUz1Qwzkks4Z2CHIr71QVKVQ0gNPJNx4bgpOr+aMKhsqowY4+egrrpAXC6kiBuiySyaROgJ6TF2HBzaFBZUlUwpCoS1RZwcwdtKq3YLexut4s8pSQQsq3M/RUdU5azWaBTVt3ZL93mrrNCyoTutFMCxKv33nlZR7NBSA0p1obXfZH7e9o9tbPKQD2FtNciXDRj89tL3tqRgN1TW1sHcMcSCECV+67546uMWQFEkO9bbtVXsshqlqvmjGaASLURUF/D6ALjaEne0hc2j0VLUhwUOUCB4IIdxHF/vRQ9R5b106uLVQJNXyA6VFF5y8tWjd5UPZSHNwi+27CydP6NsYa0wrI9EUUHEHQAmP5Hh2pBJZH9WOKEpg+LohdPTEJHZEczxP1nWRg62+LzsiK7qn+0LvVn0FdoSdQmm3I/CU7nU0Fz1cSLifA9uSSg7muLbE9CxF0lDR+KnakhcedDYEIkir7urb21ETZqlgWLDsgUm5jhjj06CkAMvsNMwjF4cdNwCKL190W7fNtnfD75odSvDmNg27fMsq/cXRDJTk2YbsoxcZvRmomirRQ0+VzJZTkF6LgWKnGNsNlJ8tHmGTgrpDtJsD26fOGcux7JNh+F6o6b0zltPbp11QtRuCFvtzt17ClOWs/OsWUXke3yeI1RRUgztK0m2RwzMrOAUB4fu/Bz87H4LZ7H/+bfYhuP5rEP7j+oNziyoFyodHHBBn5tsY4qUoSwcG9MUqJ4OSek3yLT8ss8WXhvAealpxigoxGXIHP/DAyr472WNddwLb9DpXG1JyNOyxbpSFkPQXfe2x8Bvbu53VzVUwsuGbuuT2Tuicizk/EF17qHTdV8NQDnovZE+O4hxbdzoUN21Vsgzv7GLznbScrpomwdSL8yB5mqO0xJIGBrte7ZsFFEOSFdduObSFzxHFV1QLcmQQaqDT2gTJPr+cXZ5FxsJp9xmVgT1lCfB40+wHRBJqdvmuuWhPR09jdy4EU22hzZck3XpgwB/yLUB6KOuq3H8xQXVMR0Tz0cqpGMP9YGCmj+Bh0VBTa3sdMDkSGseoQPNM3Uc2thqHCULXMX2hYysHKPfpXxcNTLdtmr0TIpOoYbweEFCOTTXsZQA7eZqIvs9IuKNja+FyRXQwLXx4fakZBsCDNVVyoIvfuA+L7Hqz3VW66Pnf87jI47s7QYCK9j6WSu69nxSP9ACaWtdM1/PRqvRVa2rDNGTHFjrr4IQ0NbuIrl1TO4sFfDEg3KS5ifMkax4xxJMH0f6OrrB5pXtnpLAVy7Fkv+0toyevsNkFXoas2BI+fqW4ehItEm1vbGT9K4C0feco12b5f//63z2zrBONXcRUa26ebAWJduyKqP5Ga4xCKZbRMkPDlDUV/rST0TqDQw6tYcH641lasVMTFc8EiljvHU+exuyyC4/aze7H6CtscbaMCsH9FsJdHd3idq56msziiiER+LmBbzbP7zy2+Z1723aNKgJR0boloQ4hUu+ieA3o60fF44MgdsesnaLjPKxBGqOEKjQ0RyYRn1LNyY4PnFQIozFStrJFpbSvFThQdusEFnKqZEmO6vTOfJTsG2xRRpBidgURGWK37qDE0jzJbVZE69mf8EeSLtY/zH5zbv8sKNaigxrXJPUX6s71TwNSKtMm5wEWNZW+v6E79ANf47w0qWeKxGCn2Ug/GJPPUbzKH4VDxq0tdgDfSJ5QJWW3d6oDD2ahp5sRWW7ZmFmjMZRzQfqyk1CT0rclCQU/WKeXSpZq2rLdYnP50lAe9CYiDeQSGgURzQaBhh5ounuoGl4KPu8cdUrX/4RRjVMQcQXbrDz7sPzOraTrVP1RMqN6Xt8GnYYKZxjm2QMsK3xHD6NEw965+hTnhZMuVlA9whPm0Hiz/FvzGmz7P8liG/79X+BvyaKZVHDlH6CldVSmudMYfC9v0qIr2ZaQbm56SW/HK1YPTLQIrmpXTYlYwcbhivTI/kYTJJ5XP6CRvqqgflWRWE3Ipsn8NQV97apmKcRXYc0ET3rgyY+G6xlqgF4X1MexX0RpcbNZJwXG1Iubv7p+XAOMxF+iBdIKCAp66cq0veACrDXQibstHkx5+jPbnTB8W1KC4yjQtvLt4Qr09wX95QKYGaoGjq0loYvIOJkXHetFTubN4wyelbuMgbserROicLh+gclOUhLqH3OOgNZXzcHDM3+bnsqxx3SJj/+P8zwTrMURp2mXbV8D5njQFRKebasDSjXvaQDtdhXPfrmeQcbOki1YxSK4XQryV3gqr4K/paf94qU1VH2gy5rl9y6kPzFVL3QA8anYA768cbKf08hb0EF7Cg/8VUjX3ozwJMwSfE0tH3mcfPQ0yOtuvYWH/yrwx8uic5cHcAE0aywO0DOsVYARGppk99/E+bYKqHCRav0an+AHZlAJWC41bV216RHAL2FfSzF8v/OxMBRXvDUomkLlFUFUIDlBc10TWXIS0RQOmqM2h+8UVELd1pSgdzWsJ0u6CnPDZ+TgjAjq5mb7ugKj1wYtgKHv2VwA//ay/GW8vApTZZ8ZYyegCS9Pj0TQttXnjt6Y0zB6+J+TG3iaFbPullqYQ0ey1H1tMK9wgKsuLclihYqb6pLEQI+tLqXAsEIbnXXbrxiGmqkx1OUfOT274fM6xockPF/e5UBVoLTC6qYy3ec82pDZwsdpvgBoDni8AsYCvgQnBS98QVnWF5X7lXxPUvhSMSIQjxvoRm8b2QSqlVsXcuyMuR6orqphW3x1Q05BmGGFPttEX6GCT1JBQWJ3QfjQUZBq8l/GDlokoPspIwwv9PhINzw11Ayr9w4twsTvCemjOq+qrgD/tW2b0kgJlErmZ78zK4BN7ubZNmCW2UL0bJoQK1THOrksCGJTcn3gfvfevPLm3Y7l3QqqPhtzZcw92xPATnF0U1X7hwbeYHdk2FkqA3XcF3WMhzxaADHYjMMvYVLAWhF6j2nUA91Sw6C3UR/VfT0/YI4IOVLPc3zIVZXdERCnObZteHrvquM3xJ23bR3kvTm+rwdKbzP6hp3RtBVeyR3I7R+CERlwODS914KR02Q/qhc8Uf77vq/aNuTTG/8PZjoOuuofwn7NCS3dN04jHnvm7IcfmO95K91CzZRcQvUyNi6bgS0bLaI4UsQKsI3SbnDEavT1v+HbshzqsOMpUDkQRfMGlnrqjP7u5vhhQNVwfcc+jWXvH/ltUsRkVmeVrWFvMaukUoqrX66v40WcbARPgm9vkmK5264qgqpe+ZrOB03uix7tgvvYIR8A0cC1pP7HnU2qizjFYiKFYd3U1b54zH4NdYwgiuWbihf2P1z6+14IHxQ4A+ycgEmDX3a20pFNMZyjAfiaQA50zTKm8kpeixXknkb7YgXpcTaA8qKGsLXV4xtC3vZivg5tjxIN8eJ0TTYCi+bJ37TgKWlBToSo+7vuJd8Pg8DrvaDXXckLEAxHUVJzAMnFKk/uiv8+P1VF98E3lAohEeIfcNjJkZdieqq9SWE91a6ByiPdShg20WIovhUGeu/6jpHRQouUTgwqJaGHbryy2Ls/d7nfWhSbzKNUEHGifQ4/eANbxt61rnik++Cq2o5imEHvYPUbXLvBlfBzOFyByY5T4J58amAW/yPYCFC1Szjn22Yjg4cHCC8oTKIUmV6YSi+VJ0xAkhxFUnsHNt6Eiefs7agtQ1VVRz2NGo5z98nYW4Bry8dSGASFurXJMX2yyqZejk9maPDol95GzlMl2MubXFbkch+g2Ht6CRVFO4I4e4q3OeH3t58F9ykJ9z69QdnZDdwEruw6iqMh6PUCbmBKKipW+j6AW9upTW4N2ehoVTY6ztPlL9dJekcqBPjgZ2+TCz3FkYwq/DoPFoK/HEXLWT29Gr8EhixZA5rfwx4EpY09XQK8UaVNcB5cadvZ99eUNs22AkltOyCMJW3ft/9A97NhFDnLZVIkWYqOq73L8ocIfhNEU7WpMV2EnR1vOy6Cpdiu3sehfPMGWuBBE+qibUKg9NFEjH6mN/E7qXvm9niL7B1uLCdV2QYeQO+3zFihIttvbmsNqBw/S9d0x+rjZ33fmp+dIqy42ijxGM3BjOdfBcW4enTymCZgJ3e4I26eHhh6/4PV3laJneyCzc7bKIHiaiYiDLujX2+axiKPF6tPEQpkwlmK4YzT/QkuE/FIq8iFE9xf/rWb9UbPEKTVQ2meqZumeyoJq9NXiDUewA9M/BJIXEqFmqSFjUOJNUszXKdN6YxUoSzLNFTWq0JZdCsgo1gWUUugSjm0/dBz4LxPSQWfzQkPfIZ2Kgk7PKNlJ1SswOvt2h5M6QQnyuZ9hrQ1Hd25pqK9yV7GkRrCPrVfeEj7/DfD0F3V1nv7bwfKvp3pQUh2a162S8lEe2udANUDPq3JW11zVcOXTq0S4lzhw84A1uCzt4ShT3FCh7KD9vEdGpCtWUtJMVzPDk+tkuz0naEmIU1PCQPb6S3ZBysWOEdng/PG4gHFAu1NHt/ZaM3M6rqiBZLhd8fU924YSKi7we1azLBP2r9stzNgesAD9bVfd3uKPeCckFEXsm/Hbe3wxwxVK9Sk3vVjIwcaztEk/D8AAAD//+xdW3OjuBL+K1N+P7UgdIGpTaq4iJ2tPVsnNZnaU7UvWxhjhzMEPBhPkvn1RxKCYBubS3zBGfJgG6FLq/tTq9UtKdmHp4/h7GaiGnjyy+2vTx9TlpCuwtnnu/Rmoii2pqi6NuFvsts778WbRsGH6cuvv/Bn/pnyV37y+BjE2WcvXgQ0nrWvM70T5dP77IXV+/TxuxfdTP7Ia/PSH0HoPwRxXsnqR/FeBUWKvdpM4/TkNRYUBfMgDWKf110hKaebfS553uWHJxV+XHqp9zvLArGLKMVgIlKz4DnjqUT+TYqu8I5YpmITt0zKe4csxaawTHSCubeOst3sdzyJUAgY6YKKnPDlBiu+Mc548cxLZ1+jIJScmKfeY3DHmfpwv/T8gFXEK31KveXNxFtnCX/6bsb+Q8IoevTSBSvJcxdJvFM84dmMwkV8M4mCuXh+kc9hHIVxIJm8Xi7TYLX6z/cgjbxlQZgi2SiprgKAUZxmJb9JLQQABRYkElZp4D/84814K5yyltiqr1hyvzO2eiBJEFBFEqfbF12Sn3kFmf9fLp2bCWCgZ7+ylyUT2ezZy9v+/meQLgLxM/OtJJ0F6UrQHS4eOBsFUaswXkQBL736wSAqflRE7ycRl6uQfU7URlWZ74bZF8ba4p2E2gbusWYTheh6X9y7UIGu8VPhvp3YVch1SVuxc5rOKXVEdAfZ6iCk/keynLNxGUkRZN4074g3LXIUElsmq5sJwqQQR5GVs4cxjeWYBvMkLTjlzbOAkytVhlQMbhJnfNh7Kz8MbyZmGnqRxMuq+uyvigdRPE7u0iSZi9+RJxoTtAXxv36zqrqjG0yAkfN7CyeLNJwxtMdFK3Lu25D0NMmy5LHIEYeC0F04/OmJFiXCODKJ4M5Gi6KYyLkfM8R0NGRzqY+Y6Y6ZNobMUZGlakJ1bAGrK4L2woGYLkLY4m28BzgMUztAHdRph3IW2SsdTVVsYNt0HKwXV/D67jDcLzZLdU1scAGNYjuH2PhXLq+0kbkG0gwxdVYnRQUi0zTtwwL7IspX+J0Vqwwvzu6XUciNNZ76KZDm/8PndcTYFTx7vuBwbgQYUC84LCvoALp2xme3SQDZxEQU8gXOiNcrsiNPgASHuAp0GgbCiIRzTDiD9jfY1ISqIdXoiJPL4eQyDoq9wCAqBQDYIzDeuUuiAoBsGsmv8nlDCl+8aRBFQZx6K8Y12dw0kmRWnBgF1MTrqkZKSg9enMQlYkXJA4jdmgc7ldziQKeyG7q4W9GQAWUWfHpL4b/6FObS3GT5NPq395KseT9y4czD52BWSsdmEt3xSO36o16ZUfs6b7ZSF282Sb4WXVCgKQrNw3SVfU64tuOPkSefXl/aSbR+jCvviwSRJU4+WV48K5/+yp/UVxpK5P7GhkcxTFgdOeWAoFIxvGbZs9aozpI6pAA6Dcv3vcuKykKi68KBE1zH7VqdrVjIBgrs4UY+rJ6hhil0Wqvn3QiBnNtkjCBN1vGMP5dRgqW3EBAvYwRFwrNEwgv7VnRknFb/b0UbLjInHIriCdA8bQfb5Dr4nMQyvt5+S/1kFgge5y+2aa+GCQvKq0S2iAge19ELahy9RVpDd/eGH4txvD2bi6FdKJrdkarq1ICU9l6ol76P0boatlseGjoEWO0d2RuYoIcpw95ueexYSGMjcZTOCaXTyeOOHEAN+90oxotKRM5B/LM936rRD6i4OnUaXABHcqbzKLjkXYNJ/FZf+tsUOrYsFdtgnLmvzC9yNoCwdQrF5mjajZ73w553CEyiYdsacXLxJcCQtwYCjTrUMHtvCB1hcjSYAAXV4OSSewCJAQxDN6W3cgRHC3BMdyBS2QkoT0ps7ASUaccEEiF1CucoQOoFI2g5GrFtc4TRVcFoj+fqOJhQLEw0qr4X8+Q6HVfHE6cKbIzMd2NthiK2wHMxCwkX0YVByrib+4sayKbqe1k8Dk9M/CuXT9qemVWfmKnrmmU0jKMj+cSIAQuG9vGJndbPgTSKGS9+loUJx3EYBzxiWD5UZTZgDUSURnPz6OiAVIGWqvU+v3tUdHxLp4xa/yEN5xnN+3ZVp3fltodSY+3E/bNbe53ywHTbI+GNNRZIPt+RcEFSTncO621IAaRQi1jOQCBlBVnqLa4PTkApVkCb7AEEOtiScHrygod0HS9awWlfjX3h1Bk8koAqeBqtMkAanTnHV4qKael6/zN6o1KsoFhs+jusFM3HZB23u8mgRX3nVomSpEMqUXFNHSpoKIAapkos+TytcL0NwqToDiEsSzIvagmwxuo6AIx3pSeoynytVWWnMFqtfnw6f3QNMk3ris2zo0vzp4iutfaZt0APIYhajj3G8IcadMvhU7TBND9X3JI/F4zHKboJbEPv7WXFBAGXn9k8toH398Dm5DbTr1Y7X0oWCbl1W/W2qLH1DNxinhWNHTLesK6ahuVyeA/HeBsaUEo+T/OsxwuyHYKecLvuAGXXVGs8JNFxHd223fYmYr9zDZKSLlbinqD2qRV1LzWNXMehsP81CSdbh1+jmkZNmO24Dm+s75hKWjR2SEkjqpu2pQ/Fjz0q6Vfg1V9r2kNJd1nEt2309Bp65wrVRg192v0ijkmBI4z1cb/I8A46UUV1sP1egrXDlE63nR7EMAy96XDNKJFzbOpQoWVDXVxRcPpNHVgr3PpvOOhUVLbfoK4JXglutTjAQrCGnYGE7scTTrsQOHjC6ZTIQDZWqIJ63GJ55aHKEkL5FiAVi8ZqtwAdtpP/55fy4TpC8r7R1K2/ZV0zEb/sQwj41vT9YJl53EJcJmHr1VZRc3UQnC/AuXN5+45Vaek2VvvfQoUxQIZwIPeCYZsVxOaQ3u4A0HRqupQ3dIkOvOLNZwIoLm3q3q1m02fIR+00qCigcdPmOKO9n2BgL5gobKRZmjEegxl21G8XJ2eO8iFLJbZhjdHhy+PkUNDh4jjRTFO1XKX3pe8jTo7mNzOwuEau3ULqkpjBJrCgrfe2F0e3UE9HXXex75WhagJIsTu69o4gQ/6VCy9tz7fq+svQIDGBc1gWR3LtQa0Iygz7DiMVayYl4xU11+nhOwNAsO1QkyjvZRa6ZoAM3LFiWRSofMfiiJPRsbIPJgA7FBig97+qG2FyLJgQQxzYbppv5D7Eiy6eNcexHTTuJ9mBQyX2IuW0EXuRadezXEKuarqW+V6s0SuQNP8SRE6T5Oujl36tHA2H0taseUWK3ZK1V5pDolAdWVxgTWJUFA0b3C1WFSNGWNNr/2HMZnYhRpm0V4w1/7dYyqWevzVBTJn0htifqgFbb3eFku4wEL9iuIkjm9kFR2TS0TjSHVx1mJGT4ZY54CKIMWqzunAcYqLXAzFywGMN0Vf4VPiymb0VX05hDuiy2/n1N8IoZ2jg+y+rfO/E2lXgZ2K7QxfW3LNCPJUt9oGlCR48BB5Tx9VIvFTrORMnH1Iht/T3mSpPy8yTJGtZojAb2PuiYz7TgmG8TtYriYTFPYcYtwtUQxHCfuAOCR1Ka3PGqpa3UywXzETg7SVLZg8oeUioyk3OcjHxSAuMS+r1Vd5VBiwgXub9kDkX66xqrDEjl497affyAiJ5lvj8f8TwmsM4uAszn9EKSLG7IZeJ+DlNZi/iByuy5nsdbv8PAAD//wMAUEsDBBQABgAIAAAAIQBl0DiFlwEAANsIAAAcAAgBd29yZC9fcmVscy9kb2N1bWVudC54bWwucmVscyCiBAEooAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSVy07DMBBF90j8Q+Q9cVKgUNS0G0DqForE1k0mDxHbkT2F9u8xhCSGphZIZjnXytyTO37MlzteB6+gdCVFQuIwIgGIVGaVKBLytL4/uyaBRiYyVksBCdmDJsvF6cn8AWqG5iNdVo0OTBehE1IiNjeU6rQEznQoGxBmJZeKMzSlKmjD0hdWAJ1E0ZQquwdZfOsZrLKEqFVm/Nf7Bn7TW+Z5lcKtTLccBI5Y0FTyjyVtejJVACakU0LTi9BxhPjcJ0MJLAM1ELT1xAXg1V/jvgYrgbZ22V/5tAeRCYk2QKc4RzD5/xHELgCv/mLLN6DMERsQesmZwtQnBZpvYSD4LFvRmUTs9UBuNUr+bNx6jjAcVFohcCeN10RyKfHH5uwlZyReM/mwtHdnWztTuPTp/wabR0A0e9HKwRKdSXglyaXANdvU1i7tJSdFdISCV6mSWuYYmnv/C8AYx1MazY48Fats5LUwosv/wut9fTCLTnEhzP6YQHzk9+92aO5nyA4z6Facg/CaxPjB6F9OahPoxTsAAAD//wMAUEsDBBQABgAIAAAAIQC195DVvwIAAPALAAASAAAAd29yZC9mb290bm90ZXMueG1stJZbb5swFMffJ+07IN5Tc8kVNamWppv6NrXbB3CNCaj4ItuE5NvP5r6SRUA1How55vz897HPgfuHM0mtExYyYXRru3eObWGKWJjQ49b+/ev7bG1bUkEawpRRvLUvWNoPu69f7vMgYkxRprC0NIPKIOdoa8dK8QAAiWJMoLwjCRJMskjdIUYAi6IEYZAzEQLPcZ2ixwVDWEo94SOkJyjtCofOw2ihgLl2NsA5QDEUCp9bhjsasgAbsO6DvAkgvULP7aP80aglMKp6oPkkkFbVIy2mka4sbjmN5PVJq2kkv09aTyP1jhPpH3DGMdWDERMEKv0ojoBA8Z7xmQZzqJK3JE3URTOdZY2BCX2foEh7NQTih6MJK0BYiFM/rClsa2eCBpX/rPE30oPSv7o1HjgdNq2ebgPwWaVS1b5iSOxK9wNDGcFUFVEDAqc6jozKOOFNdSBTaXowriGnWwE4kbR+L+fuwFT7V2k7lNvQAofIr/aOpKXy20TXGbCbBtF4DJHw95y1EqJPcDvxpNB0gusOLD41wOsBlggP/FjUjHXFAKjNbsNJBqZVzSl3xXCSNrDuwBr4UUwHEGajEJ5f6zA3495hyVCF8ThcvUfA+EIFYyibpCmJ0cBCUBPnHWJ5wFKGmnpmmHhc0BYN8EI6e8iPn0vUH4JlvKUln6M9tyU7N39PI1hVwneLkPycmNcYcl3JCQqej5QJ+JZqRTp9LZ2BVrEDptUH2dyKLj4XdnN+qk6Umk6YWaYk2rvOX6CVB+rCNVFiDgVUTNjaZPJp5hYvcu05D8zYszb6i73n7vcru7Dqb6wy1lV1GVf9Sxq+bG3H2birp6fWdMARzFLVH/lpTN8O7uPToZhQmKZRA3b3oLDplhdtrfzqKhCjKqFZ8eF5/bgi59qC9o7nbfzF/17QVWG3Ftd5kLs/AAAA//8DAFBLAwQUAAYACAAAACEAM21Txb8CAADqCwAAEQAAAHdvcmQvZW5kbm90ZXMueG1stJZbb5swFMffJ+07IN5TA7mjJlWVdFPfpnX7AK4xARVfZJuQfPsdEy5ZySqgWh6Mc+zz89/HPgfuH04sc45U6VTwjevfea5DORFRyg8b9/evb5OV62iDeYQzwenGPVPtPmy/frkvQsojLgzVDiC4DgtJNm5ijAwR0iShDOs7lhIltIjNHREMiThOCUWFUBEKPN8re1IJQrWG9XaYH7F2Kxw59aNFChfgbIEzRBKsDD21DH8wZI7WaNUFBSNAsMPA76Kmg1ELZFV1QLNRIFDVIc3HkW5sbjGOFHRJy3GkaZe0GkfqXCfWveBCUg6DsVAMG/irDohh9ZbLCYAlNulrmqXmDExvUWNwyt9GKAKvhsCm0WDCEjER0Wwa1RSxcXPFw8p/0vhb6eHFv3o0HjTrtywst0b0ZDJtal/VJ3YX970gOaPclFFDimYQR8F1ksqmOrCxNBhMasjxowAcWVbPK6TfM9X+Vdr2l2NogX3kV2fHsovyj4m+1+M0LaLx6CPh7zVrJQxucLvwqNBcBdfvWXxqQNABLAjt+bKoGauKgUib3ZaT9kyrmnM5FctJ28D6PWvgezFXgCgfhAimtQ77sO5XLB2ZKBmGq88IWV9scIJ1kzQXYtyzENTE2RXxcsEyQZp6Zpl0WNDmDfDMrs5QHj6XqN+VyGVLSz9He25LdmE/ngawqoS/LkL6c2JeEiyhkjMSPh+4UPg1A0WQvg5koFOegG3hIttH2aWn0m7vT9WJM9uJcseWRHfbfgQ6RWjOEoCaSqywEcoFk02niV/Ok+A4C+3YMxi93Xo/97ydW1rhFWusdVn9rCt8kEY/YaK39pdPT61pT2OcZ6Y78sOaHvf+7mlfLqhs06hB23tU2qCVZVsJv7UHIrhJeV6+dV7e78e7sZ35LJgud7PH/72dm8I+2Frb19s/AAAA//8DAFBLAwQUAAYACAAAACEAidCLEoIDAAASEAAAEAAAAHdvcmQvZm9vdGVyMS54bWy0l8lu2zAQhu8F+g6CjgUSWvIuxAnSxA5ySGtkufXCUJQtlCIFkvLSou/eoTa7VZrScuKDJZOcjzPDf0by2cUmYc6KShULPnG9047rUE5EGPPFxH16nJ2MXEdpzEPMBKcTd0uVe3H+8cPZOoi0dMCaq2Cdkom71DoNEFJkSROsTpOYSKFEpE+JSJCIophQtBYyRH7H6+R3qRSEKgVbXWG+wsotcWRjRwslXoOxAfYQWWKp6WbH8A6G9NEYjZogvwUIIvS9Jqp7MGqAjFcNUK8VCLxqkPrtSC8EN2hH8pukYTtSt0katSM15JQ0BS5SymEyEjLBGn7KBUqw/J6lJwBOsY6fYxbrLTA7gwqDY/69hUdgVROSbngwYYgSEVLWDSuKmLiZ5EFpf1LbG9eDwr681BaU2W0L240R3WimdGUrbXJXmF8LkiWU6zxrSFIGeRRcLeO07g5JWxpMLivI6rUErBJWrVunnmWp/au1XRfHsAPauF+eXcIKz18neh2L0zSI2sLGhT/3rDxJQMG7jVulZi+5nmXzqQB+AzAg1PJhUTFGJQORXXUbTmxZVhWnOBXDiXeJ9Sx74N/O7AHC7CCE3638MBdjvsdSoQ6Xh+GqM0LGFmu8xKoumoIYWTaCitjbIxYCY4LU/cww6WFJ69fAbbJ3huniuEK9kSJLd7T4ONrtrmWvzXvTAayy4PebkDrOmYclTqGTJyS4XXAh8TMDj6B8HahAJz8B8w1CNpf8lm7ycaOf8iZi5ibMHNMS3XN4/0thoBekWOJbqB3/c3/mT0e+m4/Co1Ob0WH5gdEA3jHD+4nb6XRHvfHVqB6ay3yw058NxvXgNY1wxnRz+dwMja+96XhQeDGX+eVBbxmEEaww6HOW/aAxoy4yU7JYwTBfVPOUnzw9mFlUTqMaJF90y5azDvT5z59EcJOAgGRSwuMH6oj++mXW6GLlm+yDn/PotBFJoFJM4ExTSRWVK+qCE1pirornZzDHC/DAed2FvaRGLLyCFyCnvnvcpoB/pgto/6UbbxFEzJWWj5Cql4Nw5pc3U8dxvn1y7qb3N9PZ1/u7y8c8jNryiHAUNeLVuUysI+JiLoWI8tz/Vwr+sRmnPHzLfP8rz3+qRUSvaCXfdzqc9mbtlLJn/87i+fJ0Z/TzcLiA7GJ8f/n0LA+hwd5BbHRlml/+Df/oz38DAAD//wMAUEsDBBQABgAIAAAAIQALmLwNLwQAAFsRAAAQAAAAd29yZC9oZWFkZXIxLnhtbMyXS2/bOBDH7wvsdzB0T/TyG3WK2E6aYHeBIE3bMy1RlhBKFEjKjxT97jsUScmqsoEsXzaHiK/5cfgfzlj69PmQksEOM57QbGG51441wFlAwyTbLqxvL/dXU2vABcpCRGiGF9YRc+vzzZ9/fNrP45ANwDrj830eLKxYiHxu2zyIcYr4dZoEjHIaieuApjaNoiTA9p6y0PYc1ylbOaMB5hy2WqFsh7ilccGhGy1kaA/GEji0gxgxgQ81wz0bMrJn9rQN8nqA4ISe20b5Z6PGtvSqBRr2AoFXLdKoH+mdw437kbw2adKP5LdJ036k1nVK2xec5jiDyYiyFAnosq2dIvZa5FcAzpFINglJxBGYzthgUJK99vAIrCpC6odnEyZ2SkNM/NBQ6MIqWDbX9leVvXR9ruz1o7LApNu2sN3MxgdBuDC2rIt2ynxNgyLFmShVsxkmoCPNeJzkVXVI+9JgMjaQ3UcC7FJi1u1zt2Oq/VdpW6sw1MAu7uvYpUR5/jHRdTpEUyIqiy4uNPc0nqRwg+uNe0lzIq7bsfgYgNcCjAPc8cfCMKaaYQd1dktO0jGtDEdFRXKSWli3Yw383ZkTQFichfB844d8SPMTFg9FGJ+HMzGypS0SKEa8ShpFjDoWAkMcnhDVBSM0qOqZZOLzRBtVwGN6EsN8e1mifmG0yGtachntsS7Ze/nedAZLJ/xpEeKXOfM1RjlU8jSYP24zytCGgEeQvgPIwEEZAfkfLrJ8lE18KMfl/dGNiMhGWAxkSbRu4P1PbIh+PDHd+CqOBFjzHYJL8oI2mBCcMcQFZpat1/yAeahA8KIJ3WMOnqBC0Gp6CZ7D62jZo7lhZfDyKQ34m7bkOQqwbgeUUHaKITgS/Sw3VAia9rNlyTbuuW2S8STED5cYf+9jbLck35C/0ZEW8hwqOFFywGEVnRVE9B9UhluL3AxleEBNMd6dVtuesOS2lL6aIzjD29IoShgXzxQYruwSpHv15IqSIpUfLmbeDJRLMvqwhE+Xqvdd9dzah+rmfmFJKJtbeAJDeT4be7N6rVkiGMzCB1P4DGBnde+sV0vJL4eemBxcjycTD976IMfmOWLoUe66mg6nt76vRuHdUsjRif4zgJfS/n408tc6y5j2kT1grWn8XMgExgcUCGlXauZO/epcxiRQ/01PZ155qnbEMvqDoVwTtE3ePMHt2lmuVt7HJ+igihpc4wgVRLSXP50MlV5oZxrV5S+aR284IVjfN7WGv5l5z1ET/G3Fm2O2Xm1X5CqgDT97YkG9m58/A5pJgeaEbumvX6Wmaonaty3uaHg39iaT0f9RXIE2qjqgjVkREIyYZOYUfpxmQ/jG0VdHr70gIEqg8hrq+2xSsC3b2L+79dzlsCmb69+N1+vZXUM2fzqcrabvKdScOV+hluNxyG7+BQAA//8DAFBLAwQUAAYACAAAACEALFlTJJACAADRCgAAEAAAAHdvcmQvaGVhZGVyMi54bWyklltvmzAUx98n7Tsg3lNDSBOCmvQh0aZqL9PafQDXmIBqY8s2uezT75j7xlYBzQN2DOfnP+eGHx6vnDlnqnQm8p3r33muQ3Mi4iw/7dyfL18Woetog/MYM5HTnXuj2n3cf/70cInSWDlgnevoIsnOTY2REUKapJRjfcczooQWibkjgiORJBmh6CJUjJae75UzqQShWsNWB5yfsXZrHLmOo8UKX8DYAleIpFgZeu0Y/mTIPdqicAhazgDBGy79ISqYjFojq2oAWs0CgaoB6X4e6R8vt55HWg5Jm3mkYEgK55EG6cSHCS4kzeFmIhTHBv6qE+JYvRVyAWCJTfaasczcgOmtGwzO8rcZisCqJfAgnkzYIC5iyoK4oYidW6g8qu0Xrb2VHlX29dBaUDZuW9hui+jVMG0aWzXGd5X5UZCC09yUXkOKMvCjyHWaybY78Lk0uJk2kPN7Djhz1jx3kf7IUvtfaztWYeiAY+TXseOsUv4+0fdGRNMiWosxEv7cs1HCIYO7jWe5pudcf2TzaQDLAWBN6MiPRcMIawYiXXVbTjayrBpOFRXLyTrH+iN74N9ieoC4mIRYBo0OO1jzHkvHJk6n4ZoYIWuLDU6xboumIiYjG0FDXPWIVYIxQdp+Zpl0mtPuW+CN92IoTx8r1K9KFLKjZR+jPXUt+2LPTRNYdcH3m5D+mJjnFEvo5JxET6dcKPzKQBGUrwMV6JQRsFdIZDuUU3ot123+1JOE2UlcOLYluns4/0lYWEUSK/wEtRMcNl4YbA9uuQqfTmNXN/UPViM4Y8Y/dq7nBeFqewjbpSNNcMFM705J/67K4dncGMiLzhjy7puQyS+aMeqi/QOqH7JjeYUD6f43AAAA//8DAFBLAwQUAAYACAAAACEAx4t77sMCAABPCwAAEAAAAHdvcmQvZm9vdGVyMi54bWyklttu2zAMQN8H7B8Mv7fyJU1So0nRtevQt2LdPkCV5dioZAmSnEu/fpTvnbfCdvJgKbR4SFEkrZvbI2fOniqdiXzj+pee69CciDjLdxv396/Hi7XraIPzGDOR0417otq93X79cnOIEqMc0M51dJBk46bGyAghTVLKsb7kGVFCi8RcEsGRSJKMUHQQKkaB53vlTCpBqNZg6h7ne6zdGkeO42ixwgdQtsAFIilWhh47hj8ZcoWu0XoICmaAYIeBP0SFk1FLZL0agBazQODVgHQ1j/SPzS3nkYIhaTWPFA5J63mkQTrxYYILSXN4mQjFsYG/aoc4Vm+FvACwxCZ7zVhmTsD0lg0GZ/nbDI9AqyXwMJ5MWCEuYsrCuKGIjVuoPKr1L1p963pU6ddDq0HZOLNg7hrRo2HaNLpqTOwq9QdBCk5zU0YNKcogjiLXaSbb7sDn0uBl2kD2nwVgz1mz7iD9kaX2v9b2UB1DBxzjfn12nFWef070vRGnaRGtxhgXPtpsPOGQwZ3hWaHpBdcf2XwaQDAALAkd+bFoGOuagUhX3ZaTjSyrhlOdiuVkXWD9kT3wb2d6gLiYhAjCxg87WPUeS8cmTqfhmjNCVhcbnGLdFk1FTEY2goa46BGrBGOCtP3MMum0oF21wBPvnaHcnVeoP5QoZEfLzqM9dS37YO9NE1h1wfebkD7PmZcUS+jknERPu1wo/MrAIyhfByrQKU/APiGR7VBO6bGU2/ypJwmzk7hwbEt0t3D/kyBYRBIr/AS14989Lv3FHdwfrRQ+ncZKV/UPpBHcMeOfG9fzwvXi+n7dip6VFd59XwXfwlb4QBNcMDNc/txbXHrxrMrhxZwYbCPaY8jPx+KdZoy6yL7SEhMIArx7pZCAsHXrZIQTQ63lapGqMPq9QQS18vu9/iBC9VpUm7Zj+YTr8PYPAAAA//8DAFBLAwQUAAYACAAAACEAnil/aDcOAADbGAEAEQAAAHdvcmQvY29tbWVudHMueG1s7J1Jk1pHEoDvEzH/oQOfJWpfOiw5ap1wzEVh2TdfME2rCbN0AC2k+fXzXkEvUmNTZBuBIHWg0YNK6n35Miuz1h9/+jQeXXwczObD6eRNh74mnYvBpD+9Gk4+vOn89mt+ZToX80VvctUbTSeDN53Pg3nnp7f//tePy8v+dDweTBbzi0bEZH65vO2/6dwsFreX3e68fzMY9+avx8P+bDqfXi9eN1/uTq+vh/1BdzmdXXUZoaS8u51N+4P5vPm90Jt87M07a3H9T3XSrma9ZVO4FSi6/ZvebDH49CiD7ixEdm3XPBfEAIKaO2T0uSi+syjVbWv1TJAACWpq9UyShEnacHMKJok9l6RhkvhzSQYm6dnjNH7+gE9vB5Pmw+vpbNxbNP+dfeiOe7M/725fNYJve4vhH8PRcPG5kUnUvZjecPInoEZNqQcJY361swTdHU+vBiN+dS9l+qZzN5tcrsu/eijfVv1yVX7956HEYFT3s83P2e7g02I0X9yXndWwWxWP0/5d61kKte5sMGo4Tifzm+Htg3cYQ6U1H97cC/n4dwA+jkf331ve0kpT+yvXFldqeBRYU/217sajVc3/XiIlFdpsRTyUqKnCl795X5Nx8wQ//jAIzRO4tNL53AtgzwSo/qCysbiXYdYyuv1H627lDCvN6l7OSiutnOEjWFrpA7+uzBMBV3c7iWD8vh7tn7b4E1nzq8XVzW7i7nXUbcv2Fr2b3vzBaFYSrysdwb1E8UTi6gEbTfsP/qyVOdgNmnwQ+Hn8RIe3H15mqP+ZTe9uH6UNXybt50eXvWyDpx1krQ3+qROav6wy7296t40nH/cvf/4wmc56f4yaGjXme9FY4EXRQPvaPMjtn/J28Klcb5+f9ZvrUfvm6u6idYmdt49B4MXysrUd2mne9O4WN9PG3bu7xXTWXhhOhothb9TU35Uyt40QcXnbm/V+bsrwLBNNKnbK1aa5XbRX9fpfW74JTq9+edMhhBthg3m4FAfXvbvR4sknRfq7WfnzfvF51NzS5cde86z+d1XN0pwvOt23P3Yfvrh6Wb/fXOh/g2FDfLIut/5ubzKZLkrL9Mvgev3JSm55XYN5zogBGFETGA2iLXoWjDiAkbKBhWxbGmfBSAAYaeqYlzGcCyMJYEQc087ytDujd7Nykcis7D8C7uH+R73Jh/tvDSavfnv/FM++8DYvG++stl7Ly8XbX2e9yXwVv7fXF/WqUwDVsWSFisGdveq24y00drWMLIRXBNBSV+Jdf/KuvcQkbR3V6RAvt7cjcemIiYa1YRX6ok13Vluvl/miQnBXX0SkETrsz1hOxzIogfAVMkQtanw9izSmEnZX8V1/HU2jSneQlE/nILQVbQR73rqr4AtJF4kh3Cte43vOni8k1SQ0EiV5TbN89nwhaSrJmhut0bcvD+vbIekzk5qaWNWdh7rbo+4g+TMlwguW0e4q+EISaM6kZLwdCd4T3/UnJYEWTjnDTwk5JIMmmkXldU2PJyJ/hpxBMjMtDGVE1XTEvxx580OJrYaisFHYqk5IMkFNEDm6/SVr37E6K5BD8gtpBOfafBundXrIISkHk16FGPEpPz6nBclCNCVNHJtqBvHQgp4jByUPTlFNGDb7MOSQfII1qbaIBJEfn9OC5CrKNYFWsB7VCZozBMlVqAiZ2TIAhciPyoI4JFdRTqnchHGoTpAFgcZCfM6NAWHgfHwWBMmDlFIu+6o5PmhBz5FDchVOWSK5+DtEvjtySK4iMrGe0/0NdKDTgjotSB4kGDOB7HEu0GlbECRX4URJ7wwih83dh+QqwnpGbN5frvK98F0e1EMJyIw3kbigLOyvP/KEbAOS+PEUmKBhfz1hJ8QXFKNGxbgrkxHR92y6s9p6vdD3QIJdHaRzdo8Z+gnZBmhWT2wSuLTH0Vq0jSrdQcJY6qQSxLQdX6i7w+lOguYZ2SytES199Gtb+EJiVhkToRb51vCFxKzacpVi1YL1s+cLGZkQXsggTRvuIt8tfCFDBSJ5rbJEvsvDtp2QfE4lrnJKGLNW8AUNMKSYjEi4kqKCLyRuF9bGLHGFWCvjgL5HgfqxfcxUauxLquAL6ms2QjnJ0bcf2DZAM/8tj96XRcloG1v4QmJWTniySaBtHNg2QDFrFN7scyHSOenu93eDWb/54V0VBwmGiTIyuLIiGZ3aFr6QAQgpnVKeZOS7nS9oXn5QMluPz+/ysI1GQbij7mhm1qY9zvQ7HdvQkGSDOsdywC0jDmwbGpJsaBuyNwEDqgq+sGQjE5Zx4sWhbQMUs1ph9D6XtZyQbYAmzXgmFHUYUx3YNiDxsI6BJR4w3/gndAdMxDUkGObGOW21R6e2la8BzUjKhHNWtV3z2fMt977786sZJ9g7vjxoo1GmS+5sGymrZCMmihV8QQt3qVaClO2mkO8WvrC9MY1WKqNvXx7W94CSDWlENgpXX1Xwhc3G4V7KMhkE+f49XwuJK3lQlIiyPcc2vlwLlUv7/DXKLz8p62rXl+rpHpAb6JwBklz2rn2kz5YbJM4mNEhB685ROlVuoL1wtLbGlkV6Z8sNErvKYAUhsn1Uz5YbJCZVhkRjZEvoCTfluFC00MR294EvKG4UUQmOs4xr+MJWX6YmpzKYU23nSwkocHRSMB9wic7ysIdxENA8bkdzFnjCWRVgSJgrVPI2pRYRAt4GGBTXGR54xCe4lXFQ9wOZbk0dMcwI7FD+J5QHHOWl5aygnf2azFGoqvQdNbdPs4PkHIxYalny2ChVAAadCOV9It7gYEANYNCUaxFi5lW9OWcPGHR8Lvc5SFnO5kL/vunOauv1Qv8OOptXOul0XR8xWgdoCa1PXnmH0U8NYNjZSiYx3O+uyDio+4GEl1rZ4AluDlAFGDQ5WjCaZPpqTAat45tbByR0lVzHKD0qrwIw6GxYGnWwyeGITw1g0KaNJCYpy5InBLwNMCR+18FQ7XAX/lbGxjurrdcL/TvolFeSpOLG4cqlGsCgQYMQrMixZsYdWsc+rQO0UTwjJjCcLVAFGJJ8SclEimVDSbSOQ1oHaNxAeBpdiRnQOrYBhiRfXBGbUtmqHAFvAQw67LYBbLTT6N9rAENyA0U0taYsHd4GuGkGHC0h7BPAmmol/SbAX369TG5eX/pemC+/dvnrm62t1wtdPuxsW5KFrDvS/uz0WcMctGmO9tzmXDM8jzb0jW0IkhESSqLlFPUJtCHQ5kUkUutNzSHOG5nnyJ1oO0nOlDloYC3zkFQ5S3Ubc26YTyWA+xrvl5+s1jCtLp0QXtDhp1J65WOu6bn76zD1y09WeB8Tz1PBCxo2SI6HkGtSg3PHC5qTEnlO1NXg9Y4E/eh7t2VeX369MF9fOiXmkEBSq0Akjy01ZA5gDgn2hJfRyzJpHZkDmIMWAYsGmS5skDmAOSTYU01CE7Sv6ehB5huYQ/rfWYrZsbIMFpkf13hKOSN055hISOVk2c8J9bm7DYGOzKWeWlK3ASgy38AckloxZ6J2Zf8iZH5cfktCBnkocTyRqiO60IY2MIedVBB1Zr6mExlt6BvbEGiz0mCM8lXHo6INbWAOys2NI8lFbIeAzEG5OZGRMVez2gaZb2AOGoghxNBIsH0+wrYCNO+OiZh1Rn0eoT4heT8RLCZWuKM+d/eJoCO3VZYqiYxjIcdnQ6AjvjW3nqoyCRT1CbAhUN6fXW5KYt/ZEdoQpE+BusyYqDoKHG1oA3PQhoBKaSGr1t8h8w3MIXm/ZMmyFDDvP0K/BelTkMpzrUoXEOoTYEOQPgUeQ9Ye+xSO0YYgfQrSu5Sjw7FnoA1B8n7FhQymLL1E5rszB53OTjQNVnBwzqKYWI0YnClzSJ6oksrCV+0qfnbMl1+3Feubra3XC9sKDckTeQqEal2zmAb1+Y31CRp7dpJmX7UJA/rEDcwhOYtqoJGm9UfmMOaQnIWknJzKbROGzI/Mb4FyFid1U0lwfyXqc3/6BOVDNDbNkAH3haI+96bPsoPHzvaZhCSpdEegPo9Mn5DcmTqhrJTob2Exi4HkzozEYH1ZkoXMAcwh+a1wPHoFHx9Cv7U/vwXaQCdYE11ZkoX6BNgQJL8VKXtiq3anQOYbmIPy2+y9yBg/H6PfAh0GnJNOsux3hPoE2BAkB6VJUpIEeF0V2tDebMhCclCmbNIqY/wMs6GySHdn5kYor6s2iUQb+sY2BMlBuU+R2LL0CPUJsCHQRqvZBC4ytv1A5pA8kZJotNXY9h+h3wLN8/XemkAxHwLaECTv10ZQ9YJ9oNCG9mdDoD4FwrknZZo96hNgQ7BxbcKCKAchI3MAc0jezzUzXlQdMo9+65v6LVY2uNs5B82eykgxfgbZECOQvF8wESJPGG8doQ1B8n5qlBcUvjeeojSvzkQ9B32ubnYXff7+w8UPP5DXhOysTUiPgmrSoSgkfNY2anNv1gnazZuGFMULerZPWJ81zCE9CkyFkE2h9p0w/z8AAAD//8xTTU/DMAz9K1V2hqWFrVtFK5VNlRCXamM3LtaWsUhZWqUuBX49iddC0ThQCSRySJwXfzz7KUzoi82ajZObcROZ3NBZutNeaWvtNb4q4TXRM6iY3RfHo9AI5k3I7UHofnwTgdYFAspCr8S+faEcNtxUcrfKTcw4n/p+FnDWK6JAP3Ulzng1ESYPBnSlKLXDscvtONO+PRFz3q1p88ldzAI+ZdaEGg+FrZ7WWBgHSC1RgqosRExKr/GvoxIM3FHUJExnizkjFMULOjRsl4unflw3tylfhNkH9KXFDlyKPdQKz93zHkQsTg2X3w/d8XCT+dnc/rOejyNvNOKXnA9Wk4Y/UM3JMguyq/lsuJq/LNwfSjL0n3zaVfIOAAD//wMAUEsDBBQABgAIAAAAIQBg/7/1AAYAAKIbAAAVAAAAd29yZC90aGVtZS90aGVtZTEueG1s7FlLbxtFHL8j8R1Ge2/9iJ0mUZ0qduwWmpQocYt6HO+Od6ee3VnNjJP6htojEhKiIA5U4sYBAZVaiUv5NIEiKFK/Av+ZXa937HHrNkFUUB+88/j934+dsS9fuRszdEyEpDxpebWLVQ+RxOcBTcKWd7Pfu7DhIalwEmDGE9LyJkR6V7bff+8y3lIRiQkC+kRu4ZYXKZVuVSrSh2UsL/KUJLA35CLGCqYirAQCnwDfmFXq1ep6JcY08VCCY2C7hwWVEnvbU75dBl+JknrBZ+JIcyUOcDCq6YecyA4T6BizlgcyAn7SJ3eVhxiWCjZaXtV8vMr25UpBxNQS2hJdz3xyupwgGNUNnQgHBWGt19i8tFvwNwCmFnHdbrfTrRX8DAD7Ppia6VLGNnobtfaUZwmUDRd5d6rNasPGl/ivLeA32+12c9PCG1A2bCzgN6rrjZ26hTegbNhc1L+90+msW3gDyobrC/jepc31ho03oIjRZLSA1vEsIlNAhpxdc8I3AL4xTYAZqlJKr4w+UUuTLcZ3uOgBwkQXK5ogNUnJEPsA7OB4ICjWEvAWwaWdbMmXC0taGJK+oKlqeR+mGMphBnnx9IcXTx+j03tPTu/9fHr//um9nxxU13ASlqmef/f5Xw8/QX8+/vb5gy/deFnG//bjp7/+8oUbqMrAZ189+v3Jo2dff/bH9w8c8B2BB2V4n8ZEohvkBB3yGAxzCCAD8XoU/QjTMsVOEkqcYE3jQHdVZKFvTDDLo2Ph2sT24C0BPcAFvDq+Yyl8FImxog7g9Si2gPucszYXTpuua1llL4yT0C1cjMu4Q4yPXbI7c/HtjlNI5mla2tCIWGoeMAg5DklCFNJ7fESIg+w2pZZf96kvuORDhW5T1MbU6ZI+HVjZNCO6RmOIy8SlIMTb8s3+LdTmzMV+lxzbSKgKzFwsCbPceBWPFY6dGuOYlZF7WEUuJY8mwrccLhVEOiSMo25AdOdYpPlITCx1r2NoRs6w77NJbCOFoiMXcg9zXkbu8lEnwnHq1JkmURn7gRxBimJ0wJVTCW5XiJ5DHHCyNNy3KLHC/eravklDS6VZguidsXCVBOF2PU7YEBPDvDLXq2OavKxxMwqdO5Nwfo0bWuWzbx66O+tb2bJ34O3lqpn5Rr0MN9+eO1wE9O3vzrt4nBwQKAgH9F1zftec//PNeVk9n39LnnVhcwafnrQNm3j5sXtIGTtSE0b2pGngEuwLerBoJoaqOOanEQxzeRYuFNiMkeDqY6qiowinIKdmJIQyZx1KlHIJlwuz7OStN+AForK15vRaCWis9nmQLa+Vr5sFGzMLzZ12KmhNM1hV2NqlswmrZcAVpdWMaovSCpOd0swj9yYUDsL6h4Taej0TDZmCGQm03zMG07Cce4hkhAOSx0jbvWhIzfhtBbfpq+Pq0jY12zNIWyVIZXGNJeKm0TtLlKYMZlHShTtXjiyxZ+gEtGrWmx7ycdryhnDegmGcAj+pexVmYdLyfJWb8spinjfYnZa16lKDLRGpkGoXyyijMls5EUtm+tebDe2H8zHA0Y1W02Jto/YvamEe5dCS4ZD4asnKbJrv8bEi4igKTtCAjcUhBr11qoI9AZXwrjC5picCKtTswMyu/LwK5n/1yasDszTCeU/SJTq1MIObcaGDmZXUK2Zzur+hKabkz8mUchr/z0zRmQsn3LVAD304BwiMdI62PC5UxKELpRH1ewJODkYW6IWgLLRKiOnfr7Wu5HjWtzIepqDgyKIOaYgEhU6nIkHIgcrtfAWzWt4V88rIGeV9plBXptlzQI4J6+vqXdf2eyiadpPcEQY3HzR7njtjEOpCfVtPPlnavO7xYCYoo19VWKnpl14Fm2dT4TVftVnHWhBXb678qk3hnoL0FzRuKnxGjAj9Qu3zQ4g+YtMTJYJEvJAdPJAuxWw0AJ2zxUyaZpVJ+KeOUbMQFHLnnF0ujnN0dnFcmnP2y8W9ubPzkeXrch45XF1ZLNFK6SZjZgt/ZvHBHZC9CxekMVPS2Efuwq20M/0XAvhkEg3p9t8AAAD//wMAUEsDBBQABgAIAAAAIQBtI260MBUAABtlAAARAAAAd29yZC9zZXR0aW5ncy54bWzEXVlvW0l2fg+Q/yDo3a3aF6XtQa3TnrTTjciTAHmjyCuLMMlLXFJ2q399TnGxZPmrSXsGgzTcNnU/1nbq7HXq6sc//bZeXXwapt1y3Ly+5D+wy4thMx8Xy82H15d/fV9fucuL3X62WcxW42Z4ffk47C7/9OZf/+XHz9e7Yb+nr+0uqIvN7no9f315v99vr6+udvP7YT3b/TBuhw2Bd+O0nu3px+nD1Xo2fXzYvpqP6+1sv7xdrpb7xyvBmLk8dTO+vnyYNtenLl6tl/Np3I13+9bkery7W86H0z/nFtMfGffYJI/zh/Ww2R9GvJqGFc1h3Ozul9vdubf139sbgffnTj79rUV8Wq/O3/vM2R9Y7udxWnxp8Uem1xpsp3E+7Ha0QevVeYLLzdPA6puOvoz9A419WuKhK2rO2eHT85nr7+tAfNOBmQ+/fV8f7tTHFbV83s9y8X39mC/9LJ8Iy83fN5lnHSwevqsLIc/zaP+05s/62i32i/vv6+68R1et7Ww/u5/tvnDksce71ff1qJ71eGSw1Tj/+LzP4fuIpr90+Lh+2sPdt9MCXH2Efl7eTrPpqDNOLL2eX7/9sBmn2e2KpkOsfUHceXGYXfubNrn9c/g4/HZ43mh7+nC3ah+I9G9Ipf0+juuLz9fbYZqTXJM+VOzyqgHTsB4/Db+Snhw3s9XbzXFepDueoXm2H8Jm8X65Hg5PZ/v9jKa8eD+st6RohovpujHq9HbBj50uhrvZw2r/fnZ7sx+3NO6nGRHCMn+E7x+398PmMMr/kO4940roU/Pljvp9/Gmclr+Pm/1slafZZ5L3P0/LRSGV/nhucVrD6fv/NUz75fz//vb4H+P+r7vh3Wz6sNzs6jg9a/DLtKSHh+9txl8fNvP9w2Ge/z5MG/rKAZjfz6bZfD9MN9vZnB4mmuM0rs7DHPpPZAYm0lKnBS+mm/vZdshHuuze/Dhe79qDE6F2F5+uh99oW4bFck9mabtcrGekQgTTjLbv0/WOBvhIhBqWH+7pa2JL31otN8Nu/9g4Y3+/3Lyn/9toVy+6pidoAp+v78Zxvxn3w6/T859oFW0vX5128sXjAwmvXrYdNotvfnjRz9dPz9181fBoOZ8+3RytMDXZzNa0yK8s67txQWby8/XDtPzjctoaHLaIq+Os8EDE8ROxwvC+id1No3ClHb5Z/t6E4C8Pu/2SejxwxT8wg781AZINGvkXUhTvH7dDHWb7B+Klf9JgB3atq+X23XKaxuntZkEK4p812MNu+G/6MulL+Z5k6GMc9/tx/dOTPvgHx716zkbk+i0OnN4+/Cdx7BdFwAy33uaTBtw1NXpG6D9VT2t4iUjjSwdx3vWQWjFiYznpuxcI5z7GDpIrHocLIfB6uLZJQEQw73AboVhnpZJ5EzDCZTEYUVF2etOS4/UoFUUfwdTRSqcEEcOjwW0MzwnPzcgsMXWMrAqv1CiVMHWMlhrvtmUi4XEsi/WkqF4i3AW8Hmuq7iBWqZP9/QbRuTM36g7vghPM4Fk7kQumgWclY7p5I7ztIRlzrycJlhAJnEksc5EXj2cdheKdNpppzFWJ6YzbJOFjp40yFa80GXb2f75BAsc7l5nTmKKZe4ZXmoXryFyW0WJ+yyY7vKdVKIl7q8K4s4/5ApGSw944M1FA3cuZDRX2RkjBEkxIxdLIOZcc7gIhRsM95VwZrHe4YBHrHS5IX8P94UIqh8cRRmCtTIjCdoErHR3kHa511HBPuTYG8xshyWKKGhs7FLWsONzGisQwra3kBvIOt8rZzjg2RygL3DHrMYc4FTAncmeExON4JQSetdccWzPubcUyxwN3CfNBEAx7ATwY0ggQiVonTIOoXcK7nXSP4zMzBs8tK+Fxb1krrPl40RFbTV651JhuVVSO5Yc0RcE0qEoxTLdqLbaahCQPxxFkL7DNEuRucEgdQgLWiRS0GUwdsplFwLkJroSE+yO4DlgWBDfkWkFECoW9QSFNNVDDkssnSgeRIkN+E+RwZaiRhDIBe9FCs8LgngrNdcb7o2U0HcR0tDIhWUPPQVgTsHUW1gYFfQrhWGRQV5E1zR0OcZaEGCK+LRUiZOk7uxCE4Xg9QUWG+SAYje2CCJZj2SakMkzRyHLBM4is4xGLyGVnfyJpHiwlUSYcSYio6A9EEsvYzokkasB7mqRieJxkiNwQybxHgywYtjKEyI6myNJH3FsRgWE+KFqd0xcvkMqswOupXFk8t0qz7rQh/w3zTpXJY31QZcZejagqdGS7Gt3RidUWrMUkaVKsE2WTR9gbIUlB+yOZ9KWDaCHhLhBSDaSB5KxgOZVcOAd1PKlrpvA4UgUc5RDvShyjS6VcxOMolbHPJ5XO2POWyrqAx9EUT+FdIPWGsytSE19BPpDaauzdSiN4wTQwUmCvRhplsGdHSAgYscwlyL3SCubxnlqK5/DcrEmdXbCmaNzG8YqjaulExJ4QIVl12pD/hnfOKZ+gNZPkEfPO3CypJIh45nF8Kn1PW0pP7g6etTccR8iS4n0cfcjAXGcGDcFcFag/vB7iao2pQ553Z5xoArbBFFNLnH+TSZKLjRFlcT5EZqlxlCMzOap4t7PuxEyE1Ip3odiisCyQlcFRm6wi4riRkJ7urdJJqA8URbWlgwh/Pkl6iciQ4G6TfnXYNpIL4DxGOCOnDyMyJ6gtFQXcAc+aHHnsKxNiNe5NqIg5UZEbjf0DctYjjiQakuEuKCmZgnaBEF0gjyqpKuZRJU3BGkkpK7HPp7RInblpQ2YGIkZ6zL3K6E4GkBDSYxCxjGFdRZMumHuVtb4za6cZlgXlrMGZBeUpEsf85nXCNkt5G7FvqULP0irSfJ31BBMc1P4q8oKzBC23j7WyijbhLLVKPHXaJBIGLNtJso4+SCpji6GSsTgboZI1+FxGFaIpnkExHsfbqvKi8NyqNBGPU43F3q1mKjvYm2ZaYU9VM4q3cW+c3Cq4c4QUTDfNbbRQ75CrXgJuI0lf4xlIUz3kA63oD16pEp1IQpOqwNaMEGWhFtOaeRzPkT3nsdPGcgV3mxCJNQWpqhCgrtKW3H+8C9ZEAWVBW+sqnpsjU49p4LTAZyzamRyhbJNG9BbT2pOzisfxZALxrL2IrtNGZ6zftDcyYn7zRuHTMR20xzk7HYyzmEdjQzuIxpZJR27wSaSOKnRmHU0SeKWJzEIHEUVhKUnkpWF+y5xECyPKYMukM3konTaWd6iTbe7wW2Guo6sKdwWvp/DQ0SFFhowpSv4o9pF07dKgWo5jZ8O4xDQgpGo4N9OynR1EZiwlhvgXx7SEZKwpDGcWc5XhnOPcICEV81tDcMbM8J4XbThFM1DmDFc8Qq4ipMROG9LLPYQUGUZ61RlGsM4JIcWtFms+I0TCtsQIybHNMkIlD3UvOW8KnyIY0vAZ9yaFxKcVhESFuUrKTpbaSKVxRsYoQSN1kIgzP0Yr2eGQdsiDe2vGEWoko03nDNmQT96ROStsZxwrku8giis8A0ucjfnAUbiNpcQJhasMjJMBnzwYz2OHQ7zVOKtrAhkzvNuBvCQ862BkZwY0M1zrYaJSCuuQaDyOPkxS5AthhPrDK83NKcYINwzPurCAz39MEcQ/GLEOn6iZ2rOnDcEVA4Z8cnyWY6ouOBdAwaHHFV7NscOeECE2dNqQSoQSTEjFltYy67B3S0gJGOEUSkD5IaTibB4JdsJ5MbKmBtcJWUGGAa9UKGHgzhFifAfRFldAWCl0hVxlpfI4xrCSohkojYQUbEusJEntIOSuQ/khxOMzCVJVFnsOhER8vmCV6GRkrGaus1ItPD6BslpanCeniYmEOYTYF9t6QhzWSNZyiqsxQsN02oji8P5YxTo8ak0JmEMclzh/bZ12OBdAcpWxt2F9zzJZL3XF1PFaOiwLgdxYTIMgJfZDbLC8M05kCUf8Ngrf0RRRxop5J8rSoVu0qWDeSSZ0qJNMxl6NTTbgKkSbW14XI4Z1ZlB0p77KVsE7urdqjnOqjnGFz/RcO6XEbbhwOBdASMZxo+MU18P1OPJuca6GHBSJbaMTFJtBKXFSVJzDd+RbYv/NSSNxltrRBHBdgFOmYE50yhpcm+c0i1hKnOZF413QKuDcOiEJy4/TmuGKDkIErvRz2hTs2TkyTB2KEm06+2Nk5xzQGcOwd0uIwDULztjA8TiuV53hSO/h/IFzpipos5yXnUyW873owwXeOdd0QTqLewuG4xyXI/2GLYaLqno866gNzrq7xDq5NJcEE502MhfMo0lxXGXgkuEd6iSTcE7VZdY5jSWkBMxvmdeMKZqFx3kkQgrDc8vK+U5vWuLzRpetc5gGxQRc8emK5RzLaSFrj2dNvj+unHeVc5zBaAjOERPSqYN0VSQcFRwQvAtVC5wpcWQvGJaFai2ODgkJuBbHt5IxyPGeyYArwAlJuCLKc1uwPfVCamx/yBGK2EfyUmp8AuUlxTKQBqRCMoec6Mku4DyS10LiMz1yuCz2vL3WDueECIk4nvPaeOx1ek3OIORRbyiUwOuh4B2fynujOlbGW5Vw5aJ33OD6A++ZwnkX76XH+UTvjc54pYFHrPl8UBVLsCc+xPGCj6zgilwfpcUayUdbcSThE3fYF/NJdGojfFIFS6NPZLgx7xCH4lyAz0LgKNRn3ZtBth7XW/rCPa4S9aWdVkOkNv2LER1x3a2vluHTl8BYxvV8hBRcPUNIxXIamAnYmpFRYDgTTEjCUU7gkgkoC4Qk7FMErirOPYVWSw11SBCc4SwBIRH7SEEQH+CVkh7FkUQQyuMcZBAUN+JZiy5FheW41oOQzjlgkCZKjKjWHUaU76xUmU7OjpDOmWvQwnV4R6vIMXW0cTijGQxL2GoGI3JnBpYHbBsJiabTRgecgwxOR6xdgmcG55EI8VhbBtLX+Ew8BMZxjjgQefBJV0NwDVMg/7rDb9F2bHBIvGK/KpDfi+1PyLwTm4UsKq5qCcUoibmqWIFPsQnpUDRS0I8jcUI8zgnFdqEW7jYhnTsCsdWN4zakXPCeRi40jlgI8ZjWkauOZxd5T+aiFBxLVpQq4Zq52EoN8awJwTXbZNAlrqmPigd89zKSE21wb1p4rP0JCdgbjJri0844pP0xDSiuxx4xKYPSoSjF9bgaKJo2OYxYjs/Eo+UO3x2LVggsCw3Btp6QTpVbtKri04roSBrxelpKptOmd+8w0vjYMkVPsQzeOc8jrvWIXjDsj0avHdaJhARchRi95fg2XgwsYf8ghka4DpLxfcAYmepol0hqHtM6Wo+zbDGRRsJtiA87OiTz3OHRLDv3t2PzYfFuZ6NwzBSzdR3Nl23otClc4mxeLCris11ybTPOOcRqArY/iYlOjjgxaXAdSmJa43uUiXxoHOkR0jnHSLxd5sSIYNgbTLwlSDuIx3m+JFjF54BJkDGBu52EiPi8MQnSb5APGqLxrEVLg3YQ0aGBML4zjlQG+weEFJyrSbSl+H5jIsuE/YOkVMfDp2V2MoBkgAWu+UlaV6yVk7YZ67dkbMV1QsmKgC1TsuQr43Gs7tQ5JGsSzrskx5PEXOVEwFFBcrIkPI5TBkfIifxurN9SpJAS9xaJDzCSKMjoIR6fY6TMOjfvE8X12G4TonGlRcomY1uSCssdaSzkI+HeKsvYF0uVZoBXWrXC/miqpHshkhlp/y6CKwYy0xzfOs+tygzudmbWYD8kc+Xx+ULmJuBKvyzaAR1GdMR1NQ3B0UeWvGCpzy1lB3chS5twPJcVT7h2MivBcRV8u16PszhZ0WbjXVDa4TxsNrKTdc+GjBnuzVqHfcvsWMX1YtkJh286EVLxTQ0y2r7DIU5FfOcue8ZxniJ73rmTkr3gOGdHotg5A8vkv+E3VxBScG4jR+5x5QghAeuDTEETrgDPFBbgvFhOtAt455LuZGhzatdVOojtcBUhuGKAkIRPY3OWGZ90EVJw/XXOOuB7HzmbirM4mTxI/P6dXHTuyE8xvsOJlTtc1U9I5/yHGEfg97sQkjsationob7O1RqcQSeHuGAJLlxXXCdUOMUycG6lXeyGeoeQgGNaQjocXwSX+OShEHGw1SxSeRwVFKkDtuhFGoHfEtIQfI7eEFxXU1Qr8IWIJu2CZ6BZ560nRSuPeacYcmMxrZvbi2ltDMf5eEI6FV7Fis77uAjxuLKnWN15z1xxUuBoqjjtsD0tnnMsc4RknD8oXnJsS4pXndxt8WSZOjOwAWvyEoTAVYglaI3vWpXIOL49QIjBN4NKVAVHYIRUXF1boilYU5Roi8U7F23FuY2SVJV41pk57N2WLCL2nkpzN/AMsgq4JqshuBKmkI7HtRGl6Iqrwgrpa3zSVYixOzqxsk6+qlQRsS9WquJYsiqjwBX2VpsJgiutTHRuqhPSqRauzHgcGVVmNT7JJyTgs5zKySmHK63thWmQ44lBHebrKoXA73askiIJTANlGY6qq+Yc33mo2lRcfVa19fg8uJpWaNdBNL6zWo3oRKG1XaHAFDUqYOtMoiix7iUkFUwdyzrVz9XKjmWq7Y0S0C40xwHXflXHCz7/qU5znKGtnjscn9agPb4bW4Ox2K+qUQSc/aqxd2O0kpTi+zI1Go5rpWpLrmMk8U7mtCZpcJ1QQ/D9hZqM7miK1LYbIhQ8Yx+pZtnRljVrj9+tRQipEYwYhs8KGoLfMFMr71RMV/JuO/qgtjdhYORcrXV1hHZvflxft18T0N7kfPzUXpl8sT62SLP17bScXbxrv0jgqn3jdvoYl5szfjvcjdPwHLl5uD2Dr14dgd16tlrVaTY/AwchWR9e/p2Hu8Pn1fGd3i++McGni+HuL1/6ai9FH6Y/T+PD9oh+nmbb46uQz1/h6phUW18vN/ufl+vz893D7c251WY2PT6DHjaLXz5NBzo9kefz9f5+WB9eKf3z7PBq5MN3F8Or9NOR2PPVdNNeezy8m223x7cn337gry9X7eXfvL3weE8/LWbTx8MPtx/ECRMHTByxww+zeVsZffv04emZOD979j15fiafnqnzM/X0TJ+f6adn5vzMtGf3j9thWi03H19ffvnYnt+Nq9X4eVj89IR/8+hIhMNrqd9u5quHxUDcsBjnu7ebm/1svzvAh1ec//+8Tv30YDV7HB/2X43UsDbU9uvx228soEGe93ZsfJCfFytpL8+fL4nXbx7Xt08vlf/hSJXVcre/GbazabYfpzP2bweMK6LZ/C2JKX06PDeKQvFTQV8b6PRbTd78LwAAAP//AwBQSwMEFAAGAAgAAAAhAFZEshL0AAAAdAEAABwAAAB3b3JkL19yZWxzL3NldHRpbmdzLnhtbC5yZWxzjJA9awMxDIb3Qv+DMXTs+ZKhlHC+UPoBgXYJ1y2LY+vuTP2FpZRLf321FBro0EUvesX7SKjbLjGIT6joc9Jy1bRSQLLZ+TRp+T683N5LgWSSMyEn0PIMKLf99VW3h2CIQzj7goIpCbWcicpGKbQzRINNLpB4MuYaDXFbJ1WM/TATqHXb3qn6myH7C6bYOS3rzq2kGM4F/sPO4+gtPGV7ipDojxXKEBnOuwFiYR+YbeoEpOXoAzBdPW4OD/UInpCf8gXezsnjYQ+spzTdrNvoiesreCQ2MLBC4zItP6y37Pja54WgJhOk6jt18av+GwAA//8DAFBLAwQUAAYACAAAACEAt/GuJK8AAAAOAQAAEwAoAGN1c3RvbVhtbC9pdGVtMS54bWwgoiQAKKAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArI/BCsIwEER/JezdpnoQKW2lIJ5EhCp48JKm2zaQ7JYkiv69QcQv8Dhv4A1Tbp/Oigf6YJgqWGY5CCTNvaGxgst5v9iACFFRrywTVkAM27rsipbvXmMQLVrUEfs2vmyqb82pya7tAcQHHJVLMDEQaYdC0VUwxTgXUgY9oVMh4xkpdQN7p2KKfpQ8DEbjjvXdIUW5yvO17ExnDY9ezdPrK/uLqi7l70z9BgAA//8DAFBLAwQUAAYACAAAACEA6Pqtw+IAAABVAQAAGAAoAGN1c3RvbVhtbC9pdGVtUHJvcHMxLnhtbCCiJAAooCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACckMFqwzAMhu+DvoPR3XWcNMla4pQ1WaHXscGuruMkhtgOtlM2xt59Djt1x53EJyF9P6qOH3pCN+m8soYB3SaApBG2U2Zg8PZ6xo+AfOCm45M1koGxcKw3D1XnDx0P3Afr5CVIjWJDxXppGXzltCmbfZHj5pw+4135RPG+zAvcnk5tRlOapdnuG1BUm3jGMxhDmA+EeDFKzf3WztLEYW+d5iGiG4jteyVka8WipQkkTZKCiCXq9bueoF7z/G6/yN7f4xptceq/lqu6TsoOjs/jJ5C6In9UK9+9ov4BAAD//wMAUEsDBBQABgAIAAAAIQBIqXUZAAcAAFAyAAASAAAAd29yZC9udW1iZXJpbmcueG1s7FrdjqM2FL6v1HeIIkVqLzbYxoCJdrbKz1BNtaqqzvYBGOJM0PInIMnkti/Vx+or1DY4JIEwxMmM0tXOxUCw/WF/3znHxzYff3kJg96appkfR3d9OAT9Ho28eO5Hz3f9v744H0i/l+VuNHeDOKJ3/S3N+r98+vGHj5tRtAqfaMoq9hhGlI02iXfXX+Z5MtK0zFvS0M2Goe+lcRYv8qEXh1q8WPge1TZxOtcQgEDcJWns0SxjOFM3WrtZv4TzXrqhzVN3wxpzQKx5SzfN6UuFAc8GMTRbI3UgpADERohgHUo/G8rUeK9qQFgJiPWqhmSoITUMzlRDQnUkSw1JryMRNaSaOYV1A48TGrHCRZyGbs5+ps9a6KZfV8kHBpy4uf/kB36+ZZjAlDCuH31V6BFrtUMI9fnZCJYWxnMa6HOJEt/1V2k0Ktt/2LXnXR8V7cvLrgUNur2Wvc7W6EseZLlsm3bhrmg+i71VSKNcsKalNGA8xlG29JNddAhV0VjhUoKs2whYh4Gst0lgR1c7FdpmhQwVYJful9qFQdHzdkQIOqjJIXYtunTh8J2yJyGz4OrFStTskQs7Bh8JgGoApkc7ThYSg5QYmld5N8fxO7qVxClU4Th+RSzsGAOPO7MHMF+dBYF02Q9+4c33sLJ5Pl+eByc10nhbN3eXbrZzmgJx0TEQSES8h1gYWBB7u3jGMel5pBk7wG24p2HyfJmj/prGq6RC8y9De6hC9oZnT2dglQ6/H4SyyzrzuHQTFslDb/TwHMWp+xSwHjH37TEP7AkF+H9myPwibumLeM7tp7xZBPxmvurxkNj/xLJA9ynLU9fLf1+FvYNfD8yVWDbJwEcpZSlkyh8WCeN4kdN0klL3K6/CUaKMv3a0dplZOeLPcvoaLwlXQe5/pmsafNkmVNbh4wmoeFxUy8MkkIXIwcAhcFqUBGte4LOLfJnojKwMi1osmXXC3cM59fzQLaFZyy9sKpNlAzjcPf/Nk08DusiLx8kfqegQo6K8yjrsHYyPURIzIU2s8+paVdGPOAMcpyhlP5Zu9CwScd0EZW2BromXi+se4a+qAdXVIOL9SmqMZ8Z4hgBRV+NpFQS0ZPdIjH///ucKYkBsoxY1RHGLHJtRWl6cOMozTnzm+Sx0PG7DpzgQTceM04MHfpRzO1u4jNESTKAoass7qKptSbqCttMJQMQZm7esLQJ2m7a8+Ma15bFAVVth10raOhaZYjjGN6ytjYTlnZCWl964svgCZcX8oaSsjScYY3R/w8peND3egrLGBcqKeKWkLBf2furcsrKVVk3K8tIbV5YHFUVlnUmbsuJp0CysMSV4bOELhO2W0tJn19sKNfhNkTKWPx4T16M8GeJBq3z2EM0pZ9eU+WG7aRz4MDlUuoSoKb3aGVEc0Sb5DumA16FjUM6b70gIPLb9KzGCrsXIcFBOOe9ICgJYgF+bFF2FlOQx3wY7d2Vuz5bhqb/IqxSpibPhQJYr0mYD62zabEwOaCsxLqWtWPJfiTbjNdqGA1lFkTkI9UqbjtRhQA4tToJcyp1xRT8syBkO5MLrHfkxEOS5zfX5Ma9pW5XHtNI3HMiKigy2BbTmYVrXHGa1qfLaMIcDWffdRko6jnSVJDT9THOWP7WPtsyLj0dr/4+TlzNzT0sl90SzCQQOKfVXWFXAe9ucmXbF0k7irslnEG9o+mcculGjhD8N4M+dNRTMXyWOHW4PHMcxRYn4vHu2RPoYY8u6YLMG6vB+akuNb1CiN0hiFAXi233nCzSZjU3iqO+UEmCbBKLxzQr0BisWRYGg0qmRPkUTAHAZB1TOKZhCEJpvfmqkpA6S231nBDjzML6VEJeKo3SIhI0xwI5VWv/3KehtpyCodBiE7XuLObD6QR+C+hiQ2QV7VEKj/Uyw7kTfSoxTOtMxCTIQ0MuZ9Lsb7Vbsh8ez13IjpdMZyzIdhGfqe/jWvUEsKP3w28gUXtvGO61QJJSJ9j5g4F+ojOYr8f2KeGhgHQBAioX1gYayb/JdUQOmiJU1TECAiaGpF9vJjaBib+oEqPDuY1CiEwKxaRUyNmJKs23CFNZ4jIls08Zs9Kch5aTfBCkOqWpjt20MsY7sFkLl1xJNoOJ85BjUJiY2EKp9MlRBCks+ASmWvbV+Mi/HBkB6sXHUCCqPh5tAxUKtphFExALEbNG9DVOsLY4xDdNApmnBYs/5bMwiHT4GZdaJLMgWjS2Mtpl9kccdo2ILGBATvcWe5BKsEbTRmTCTyISk2P9s7mmbkRZT5TGohQjBBiP2NKpYDJ8CbfQm3TIMYmOrRSnY5qJiZ7RuqDrRMcFALzbEGmHlJyqNqI0ehSBGECLbbjFV2OansNGrWKRmvmrgNmuFB75aXIup8dN/AAAA//8DAFBLAwQUAAYACAAAACEAfUiQTTQUAABlugAADwAAAHdvcmQvc3R5bGVzLnhtbOxd23LcOJJ934j9B4aedh/cqpuqJMe4J3QdOdp2ayy5O6JfNlgkSsU2i6zmRbL8LRuxHzM/triRBTIBFhNE2X6Y6Yixqog8BPJkJjIBFPm3v3/ZxN4TyfIoTd4cjX8aHXkkCdIwSh7fHH16uHl1euTlhZ+Efpwm5M3RC8mP/v7zf/7H355f58VLTHKPAiT5603w5mhdFNvXx8d5sCYbP/8p3ZKEXlyl2cYv6Mfs8XjjZ5/L7asg3Wz9IlpGcVS8HE9Go/mRhMn6oKSrVRSQqzQoNyQpuPxxRmKKmCb5OtrmFdpzH7TnNAu3WRqQPKeD3sQCb+NHSQ0zngGgTRRkaZ6uip/oYGSPOBQVH4/4X5t4B3CCA5gAgHlAvuAwTiXGMZVUcaIQhzOvcaJQwbHrjAIQliiIybTqB/uHiStYeViEaxxcxdExk/ULf+3n6ybiKsYhzhREYWBxGnxWMQlOaSc14MuGcbgJXr99TNLMX8YUiVqlRw3L48Ds/yk/7B/+J/nCv2dqkX+sYvYH1drP1HXDNLgiK7+Mi5x9zO4y+VF+4v/cpEmRe8+v/TyIojdHD9GGevsH8ux9TDc+dY7n18TPi/M88rUX1+dJrhcLcvj1Mbtl7CeP9PqTTzUfkleXt82b1F8to5Ai+9mr+3MmeCz7LP5VRrKtP4lWrWHTiEHjx70IY/QqWb2jhJHwvqAX3hyN2K3ol5/e3mVRmtFQ9ebo7Ex+eU820W0UhiRRGibrKCS/r0nyKSfh7vt/3nBrkF8EaZnQv6eLOacizsPrLwHZsuBFryb+ht76AxOIWesy2t2ci/9VgY2lznTya+KzCO6Nh0NMhkNMtRBlS1u8ryjcWRuXkwNx9yOdOEOaO0NaOEM67YmE1b+AcYcbJSGNW7x9rriXMGLEuAUON1wHONx6HeBwa3WAw23VAQ63VAc43E4d4HArdYDDjXAQTpEGJitUjH2K9keGa7DKwbgGKx2Ma7DawbgGKx6Ma7DqwbgGKx+Ma7D6wbgGLxiEK7IS7y11s6QY7GWrNC2StCBeQb4MR/MTisUrQDd4bI4j2V4lGjKZ7lGbcNGhTk7Eg9ECn3/ebzIiT7Ke4AtWuXjpyltFj2VG8sEdJ8kTiWlN7/lhSPEcAmakKDODRmyMPCMrkpEkIC4t3R1oHCXES8rN0oFtbv1HZ1gkCR2rr0J0EiVqg/bLYs2cJHJg1Bs/yNLhXUt9Z/HhXZQP1xUD8S7KOCaOsD64MTGONbxY4DDDawUOM7xU4DDDKwWFM1cqkmiONCXRHClMojnSm7BPV3qTaI70JtEc6U2iDdfbQ1TEPMSrWce4/4rTZZyyRfzB/biPHhOfJgDDpxu53ujd+Zn/mPnbtceWVfWw6pix97lIwxfvwcWcViO5SvS5iVzSUUdJOVyhDTRXzlXjOXKvGs+Rg9V4w13sPU2TWYJ221HgYDylXBZap+VIvZz23o9LkdAO9za/GG5hOwe4ibLcmRvoYR1Y8AeWzjI6XUS+XS+Hd2yHNdyt2lHJafckpINesh0/N2H49mVLMlqWfR6MdJPGcfpMQneI90WWCltrroWYJa4327WfR7w46itTbfB77/3t4C7fxX6UuGHm+tXGj2LPXY5w+/D+nfeQblkhyQKmG8CLtCjSjTNMufj3X7+T5X+76eA5LXOTF0ejPXe0AMTBLiMH04hASkNHSDSRjJLIySzJ8X4hL8vUz0I3aHcZEUceCuII8d7fbEVa4cC3aOR7pgHHQb7D8X7zs4it/LhyqgcnYMrCYF4u/yTB8FD3IfWcrP38WhZ8hZEns1zaHdzwRKABNzwJ4GzS6YHZr4PBNuCGD7YB52qwl7Gf55Fx19Qaz9VwKzzX4x1e3km8NE6zVRm7U2AF6EyDFaAzFaZxuUlylyPmeA4HzPFcj9ehyXA8B4tuHO8fWRQ6I4ODuWKCg7migYO54oCDOSVg+KEcBWz4yRwFbPjxHAHmKAVQwFzZmdPp39E+jgLmys44mCs742Cu7IyDubKz6ZVHViuaBLubYhRIVzanQLqbaJKCbLZp5mcvjiCvY/LoO1gCFWh3WbpiP7ZIE3HE2QEkW4WOHSbbAs4Vyb+TpbOuMSyX/XKw5unHcZp2ra0NOS+1m4Eg1D6phzXZDC+r72I/IOs0DklmGKNZltbP91s/MC7Mt3f8eu2XvIse14V3v64X/FWYeZdahGRV0TfE9t9Qx8F80iH2noRRuak6Cn+LMJ/2Fwa/QpjP9gvvUo2G5ElPSXjP+X7JXRrdkFz0lIT3PO0pCX5kMT/rkLzys89aQ1h02U9dBBqMb9FlRbWw9rZdhlRL6kxw0WVFDVfxzoOAbSdAdvr5jFm+n/OY5TFeZEbBuJMZpbdfmSG6HOwjeYrY1I+Jovx+9QGK9u2mPMvuFTn/WaZiYV+Vn/Bz0L3k39LMKsmJp8WZ9j+m0ogyZj32DjdmiN5xxwzROwCZIXpFIqM4KiSZUXrHJjNE7yBlhkBHKzgj4KIVlMdFKyhvE60gik20GpAFmCF6pwNmCLSjQgi0ow7IFMwQKEcF4laOClHQjgoh0I4KIdCOChMwnKNCeZyjQnkbR4UoNo4KUdCOCiHQjgoh0I4KIdCOCiHQjmqZ2xvFrRwVoqAdFUKgHRVCoB2V54sDHBXK4xwVyts4KkSxcVSIgnZUCIF2VAiBdlQIgXZUCIF2VAiBclQgbuWoEAXtqBAC7agQAu2o4KkMSEeF8jhHhfI2jgpRbBwVoqAdFUKgHRVCoB0VQqAdFUKgHRVCoBwViFs5KkRBOyqEQDsqhEA7KnjoCdJRoTzOUaG8jaNCFBtHhShoR4UQaEeFEGhHhRBoR4UQaEeFEChHBeJWjgpR0I4KIdCOCiG67FPuYZoO3o/xq54mqEn/rSvZqY/qr7lVqGl/qKpXDazOHbYpL/J7gV+k6Wev/jFiNyqvSPqhRss4SvkitmFnXsXt8raHXy+7f/GjAvVnWv5Igm+eApxZX0mwljLrMnVVEhR3sy4LVyVBtjnrirqqJJj+Zl3BlvtjdVqFTkNAuCu8KMJjg3hXlFbEoYq7rEURhBruisiKIFRwVxxWBE88FpTb0ic99TSvD54ChC5zVBAWZoQus4RcVWEYOkZf0swIfdkzI/Sl0YyA4tMIgyfWDIVm2AxlRzV0MyzV9o5qRsBSDRGsqAYw9lRDKGuqIZQd1TAwYqmGCFiq7YOzGcGKagBjTzWEsqYaQtlRDacyLNUQAUs1RMBSPXBCNsLYUw2hrKmGUHZUw+QOSzVEwFINEbBUQwQrqgGMPdUQyppqCGVHNaiO0VRDBCzVEAFLNUSwohrA2FMNoayphlBdVPPVkwbVKIYVcVwSpgjiJmRFEBecFUGLakmRtqyWFATLaglyVXGOq5ZU0swIfdkzI/Sl0YyA4tMIgyfWDIVm2AxlRzWuWtJRbe+oZgQs1bhqyUg1rlrqpBpXLXVSjauWzFTjqiUd1bhqSUe1fXA2I1hRjauWOqnGVUudVOOqJTPVuGpJRzWuWtJRjauWdFQPnJCNMPZU46qlTqpx1ZKZaly1pKMaVy3pqMZVSzqqcdWSkWpctdRJNa5a6qQaVy2ZqcZVSzqqcdWSjmpctaSjGlctGanGVUudVOOqpU6qcdXSeyoSOXg21P3GzwrP3aPibv18XfjDn0v4KclInsZPJPTcDvUdapTHz423RjFs/ho82r6gOmMPP1d+phSKh79KQN7wbcgen8fep5eF/P1PrC+efOeVfO0T77LcsOV/ZzmtqmWb0ejq/OTqRtrCVryrKxc/MqVtluw5XLQfM/5rJH9VkIx/EH2XzQ1v+Lr042iZRUxw99It5Uv5Ri/lG/Ymr+oj70/+9ZIB8p5OKnsVb/XaQZLk1ad72aPqxV1cOXvUWStwSbI8WGfRqhgDHe5efcVvvvQpeb8y0vnVWvX8YsIe/qi9wmy/uqLc7Y9gLV9VZqbn4nwxu7lq0JOKB0y9e4rrZlpClqLLl7nUZdW62lVuaJcHy+EanBg1KOlzqsGJMw1W7mgw6cra+G/A2TP1/0yza/mdsNxCuXIRhdKAK+UHLBpX91qcsv8qDpoMtFjh0+hwVqZGVuSJCKesTJ2xwm3mAKwo3AxX7syoXHloxFK5uylEVVJSbsQfUbzTk2SRXntbq5jnT8eKAIzqk0ZYr05ZQho4/N54f0+oNnzv4kEJ7rvvOHRZIbLHqsfEjXGfGPUvj94cXv+S6EPpn8P/sPoXL57U6V8WAU71b69Fbg1Ai5ETHSyMOpBlzOFtUCrbjQ1GCcOIyapghcJYOhLUaTU/8Y7Zq+/UqD45KbpRnzobdalScvZtVVnd4BDmeWbUr6xwv61+JamHCpdVKguz4f2aDNZUlYF8tK+h4Dpf5n7x9VWlCqljWv0BLRte18H7vavFq9ayxmgptVk4ikEYOl+w2r+j46IgJA/+ksS0Ybu3jccHG/p4Jg1mXydpl5axUDz94y33gWf5wCbR2fCLL6Do9Uvan/e+aJ1uzU2ZF4mr4xF/slvr+lI8pNwon/FFKyPAcbMz4mO3vYgXk8mD0wa1/0KYfUZ5oVM5P9Y/VNs97Tkoc6qee9ag3cd2Vdru6L/+d9fCG3u7DL8VOcy+IQjUF8KSHWOBcLgVBhYVcDVyvQLBvxOLD40OINYj8OyIireTnYljdmTh3mJnMT4dodkxFWo6og5YUH9fCkV53Enh1DGFsj504WAOKGy5nHGJzwE7jcSog51Knek6IULDgKCqicfaeLKRjqFmimReAZleTsdXsnI0FjdqxqNf5Wsp6x8XFpqp9XBTfiWRJjWQ75ntGu7nmE5z0Agl4s6ezbNcUz1nV+PrM+mucsQ0v+Fr5PTfqh2f0dkQtikN7WfzKcdiMzdvu7806eu/6jja2rkp//V//KoTt604sNbWIdfjqzuO5b0OukLfw2GF1Rl9VTFKSy/VRMm2FpCTRD2G3bZYu/+7K0LJzfTPwO95Fokn4EoixWcu0ZgtR/R/NzfSvKovMQtC+tH8wYw2ofnwhl5oD0h9IbCLIdl28p5EBUm++usYdFF9z/D37OIv6Ya9psrPaBQIaIoPOqp9Y7NFzBlS3KF9pBkphvnNBcnLYE2/5ZutbfXA95MdwIdOqQ+dyhLBoQ9di7dJJybq4fur3YztiWTFeRw91qaTl1uWPGbRlhuLbTpRjYe/Hds0GH5RZ7+da03WsbjvDCNXSXZJNBiAbOGpqXvnQJTZyC+L9CMJ2Vu4iMEbtVXx5WRycS3dVGZFfwbVZZEMCS0MXvzqUM1TEdTctJVCr/1PH+IQ1qmUdNWGoJU11pFVa45KWO1pkYcJoKAUkNn/ZKTP/xsZWNXEUj/blT79Z6vFe9J/cVHNY2u4XVK8d9SaDJ+dXhIWyVP82WIkq1lzFTAbVbHAdRXQHFNbTfVVJ3XAjo491uZiZcbhyRwZ3J2V7bXy77cZCdbLmGpUP6M03h2AM9Y29o5AB8lQW/8P/jrd8FWTnXZ230nt775gypefWvHQWW7VVWnpNNPWfLuREwcAfOv4+BGVf3hXoAmHny1pMVMmj4CM+qHovCtrxXb7TlhNpd6cjMcjuW85fPbWrA+E5NXV9RB17Gb2NaFEtRWieZWlzjSb+QFvoW59ai5/2wygzyk/aHhOg0FDB4Y5UGnhaB5UEGVSbGnJ32ZP6Vusf7WU0slCn7OrRoW7mQi/RVKLt2EWLPYYMWtitmKDpvTKZFD6Lf7vv/H5bU1WaKJb6Xqj1dm1WduHtd394Rhps7Wmbh/ev+Ov+m6riF3w+BVcFNw73qvT2dn4stvm0jKLSOZ9IM+t5CnakJx97X2kWRL/IUVlf00RboPKV6Knu/RAt+U+qKBl6votzcSrxOldYcXAFdp427jO6syhEtyhzz5Xp/ePzkbXV3u3vdhBGDZUUe9WWaepwfh0KlMvU4vJovq1lKnFdF49edTUYnZSrYiaWpzMqi0qU4v5bLynp4tpta9vanE6qZ7W16GwPT0dj0aLfUodnZ3t6et4fDba09nxhHZ3T5PpojqNYmwym5/olzz6ujPCY3Xp++VtPz/tO0fr/UrrvY1mThJOGDaGOHSf9RhTaNVM6b1Cap+1Gad87Y64aeZ1do0fcyM9TziaZ2OH2Z/cY+nIQ+oWFvb0w2yhWW2ofy5p756AZprb6p5spdOOZscDtcXOjj23ttx2h7z2D7o+CFsPT+7VJBn1Lc3+ND/zyh+PrB1O6+BsvzEc9PxF5dcu1mGfG2d1L9IsJJlIOPhZXI4j9zaZSr+yH6SwP2hCTOQJJc7UmyO2qyX7IE7qWsnWp3itpKszvlbCEaUgJLfDxH+zE2dzt6J+8bGnne/fx5SWD8Nd+3pf+1eXxlre9W//+Ld//BD+0XfyU5fToYfw/X3lujCs77+E82Mcna18X7sj17ioiyzN0rqpxcvR5OqmWQrDA7LjCTgi2/zN1Svxjoa9BVG9hdFnZaNuzLeHWs36hKLqkSCutkI6CPorMx7W+CvzmgRYHpI8OV2cLeSRQqnlVUbvc5cxlbF3lrNezfjzwp5pl6lTZ2mZhOzz03kSrJmfswN4UsXNL76wtw7wX+u8sLL7dCpdcN+6yMm8pr5quu+ANbMaWq0w0uoPH0umU/LFr7aN8nK7zUie//pEstjfooxLZz/KZlmS3mVpugL2IlZFDmET+gO0imF0nKFVLGuIgTQsQgy9pkmwQStoAxtA87BqcnFAvlOVu9Nf1zpFNn7ZwX27Q5G9CiaUNoGGlq345N62duP9Y69C/uhlWWqyeSCr26+n/vv97m3sghS0qda+xCU3lnU+mZ5Ur0Sy8FNz1Ky0604XWtOSuuhnVIdTw/xbqOEhKgg8xk6VIC58Xw2In2rvNKAk8d1eZjriWf2V//z/AAAA//8DAFBLAwQUAAYACAAAACEAIMOx1moCAAB4FQAAFAAAAHdvcmQvd2ViU2V0dGluZ3MueG1s7JhNb9sgGMfvk/YdLN9b4zeKoyaVoqrTpG6rtm53gnGMyosFpG766Qd2krrrDvUu88EX8/DA8/MDf8Ayl1dPggePVBum5DKMz0EYUElUyeR2Gf68vzlDYWAsliXmStJluKcmvFp9/HDZLlq6+UGtdT1N4CjSLARZhrW1zSKKDKmpwOZcNVS6xkppga2r6m0ksH7YNWdEiQZbtmGc2X2UAADDA0a/h6KqihF6rchOUGm7+EhT7ohKmpo15khr30NrlS4brQg1xo1H8J4nMJMnTJy9AQlGtDKqsuduMIeMOpQLj0FnCf4CyMcBkjcASOjTOAY6MCIXOeSwchwHnjisHHD+LZkBoNyNQiTpMQ9f+PABy5S2rMfhjhpFPhZbXGNTvyZWfBwxGxD7BcYVeRgy6bhJy0/AvfAaCrL4vJVK4w13JLcqA7ewgg7sn04fX3Qmfer8floORsW94WZt5fZvyR7NoQzahV8RWVKkBcwS0LVvVLm/7toesZuFOIy81+3eW1rZoxecvN/Ztv6L+141b51rZa0Sf/hdHutSe8u+xEh36oSuYp59P280mNCDTRRX7rDAO6t6BB9kNi5y8yqjcbF6OPIxodHLoHvztRwwvkBpClEyyzEFOYoki1GBinl3TEOOHOR5mhdolmMKcsQAZgAmMMtnPSahh/tuXKA0TuevxzT0QBDAHAEwn1cT0aNAeZym+cWsx0T0KOKkQHDeH9PQo0iKBCL3AzLrMQU9EpBmcQyybP79+G969GV3aaIaywR7pjdKr7VqDdX92yjff5O/vtx2Ncy5au++fuppg/vS1W8AAAD//wMAUEsDBBQABgAIAAAAIQAwlH7gBwcAAGMtAAAZAAAAd29yZC9jb21tZW50c0V4dGVuZGVkLnhtbKSX2XKjRhSG71OVd1Bxb9N7N6rxTEEvqblO8gAMIIsatgJkyW+fRhKSMkpcHPnGIIn/O/uh/eXboa5Wb0U/lG3zEuBnFKyKJmvzsnl9Cf7+yz2pYDWMaZOnVdsUL8F7MQTfvv7+25c95uusreuiGQd7WHlMM6z3XfYSbMexW4fhkG2LOh2e6zLr26HdjM/+8bDdbMqsCPdtn4cEYXS86/o2K4bB29Rp85YOwRmXHZbR8j7de/EEZGG2TfuxOFwZGAzhYRSqexB5AOQjJPgeRcEoEU5e3YHYQyDv1R2JP0b6j+DEYyRyT5KPkeg9ST1Gumun+r7B265o/I+btq/T0X/sX8M67X/uuicP7tKx/FFW5fjumUjMmLRsfj7gkVddCDXNwQQZ1m1eVDSfKe1LsOub9Vn/dNFPrq9P+vPloiiqZWa9uSgsDmM1jLO2X5K7k9y02W7aLceshX1R+Ty2zbAtu8t2qB+l+R+3M+TtowS81dX83L7DC0ft/1abOZXhClzi/rl2dXXy/GMiRguqOSEuiiUu/Nvm7EntO/hq+KHU3CQXL1w+M4DcAURWLHxZzAx1ZoTZdbonTrlwrGbOqSoTp7wmFi/cgb86cwPIdyAEobMf02WS37CGfMy3MNxco3DSpmO6TYfL0JyIm4WLYCayG+Kpwao2u+yziVnAksYvwPf6pobd6+cG9Y++3XVXWvk52vfryt5PBygA6zzwt0to+Jwzf27Tzm/yOlt/f23aPv1ReY/8+K78BK6OFZj++kaeLsfb4nD8fuqf882mmm7y3WpaicHX24OgnR7m6y7t0+9+iqjjFlthguO3+fH8iILwIwlWmmDNCEAiIk20iyRAInFMEm40QIJiIuOIWoCE2IgJo2OIFcdYIhAkYzxGyiiCIY4hrpjUECuEcW0kg8QinWYyYgwSvkI0ERTiGMIGCU4h4SMnqZISEgvhEisD62TEEkYcxAolnBM6HRKXxyKJEYmEdLJkChMkIPPip5I5E0NK6TuMUqkgjhGeCG0MxIrEyKfYQqYSxwJLRCDhE198ZhBEImKfMB0lEMeYdiTCCGRFCOdTBmmYxDlvBJJkIUTsEtBSophY5ChkjTOHooRiyLwwQpRGoKXkp4snsQJZiRKCIgepC7OUYaIhbUmtJgxrSI9RIwiNMSTJUvM4jkDVp8bX0oIGGcdcMKQoxLHI8UixCLJhjPX/YYIkMqLCGtBRwS9xrrnioOonUjgOkQhLhbMWkmRmjVXMwjo5Mo6DXnwsMQ5zCRpkxUTMKSQWHlGTJBjSMBRRG1kGsSIMSxTsLYaE4jrGv7yR/wEAAP//lFjdCqU1DHwV2RfYJE3SVlyhaRLwMRbXS39QQR/f6pUgCHN5Dgz9kplMpv347Td/sH39/c8//vjDT7/Xn1/9/euXz79+/u7Lpw9mxz2oP/zz75eff/rh0wf68PH/IH7deocDEG7Zu/ggkHOkbyOQuW/HugpABjVJEwKhrWsyBBkh6nyQjs28UuMivIx1ztwzkFOaxhBh7JQpgwZySrXXToRK5+lKgpzCtKZ7Q7XY0l5eAET3CDMn5JTrTy4D6hjV6TgLkSVfU75Ik2nOvbYisrS7lcgEoXJRrmUT6Zim65iYXdRjf0HsH1OJawj7h7tVkQ9Tr9hVG2nyGnckdAofWrIU0ZhapzokGKHNWwpxGIooioWMGOvNHpDGRvQ1E2Qq7dhzS0z8UeFxoJXEq6TWRSC+b9CAICpcVsiI2ZiZFgiEc95dBxkxoyyzCS2+u3ieRqikMn9rCdmVfJ+RdSIGO4XWFcguniS10pDySYPzCCR+p2cwBlmfv2V5JlKL0+S9FsQLtRoJ5Pwzxu5G7IKYcg+GIJS8YyXCfo9bT2UQ+88tshFZWp1xb0May9EvWSOQ6ZdsJLKSNCzDCFGya/ueE7pZPBrvDERjUtlHCHJ+NT+2IOsL3oRFazkr59nIVDKdUcRQUNw5WwIRv9+1PArKMOu8QJpILU6WIgfaYkSLE7pZkGj2G03IYCVLMFm2eWkj8zLHDvaByJL7NLsgGuPTIqpIk819qkG70qRe6LvQ3vcY0w0xpZG33+gjVFqc6jzIIPtQuy8pI4KZ/LLCQHjx8taAMv+oSzwnspKeiXEHlC7cRek1ACm/uo43EkhetJ56EpGlc75SFrYrX7goR2rho77NkA8TyrtDEY3pGRkOzcu4e+VRaCNXB20oXVBHaENN5q5ZNqC3vhdFqRRZSeL73d4bafK77HpMLFtGJW3oIYJ63fFyDFI+5Zp7IuVbxF6XEV7mUnYsKRGNEeRQtjwkVxlS8pQVCj0RSAdbMtJkFb05ClLyCz3KUITzR0yqQdcEvpWKKdlf4l8ChV6yedaF3pSypcf+r1t+/Bfmt/rz278AAAD//wMAUEsDBBQABgAIAAAAIQAQQG/2iQkAANs7AAAUAAAAd29yZC9jb21tZW50c0lkcy54bWyklttym0gQhu9Tte+g4t5mTsyAKkqKg0jpOtkHIIAsKpwKkCW/fWYkISlh3dvCNwYL+pue7v5/5vPXY1UuXvOuL5p6ZdFnYi3yOm2yon5ZWf/+iJ9ca9EPSZ0lZVPnK+st762vX/759PlAZVpky7Spqrwe+k3WLzSq7peHNl1Zu2Fol7bdp7u8Svrnqki7pm+2w7N+32622yLN7UPTZTYjlJzu2q5J877X64ZJ/Zr01gWXHnG0rEsOOtgAhZ3ukm7IjzcGfRji2J7tTkFsBkjvkNEpij+MkrbJagISs0A6qwnJmUf6j83JeSQ2Jal5JD4lufNIk3GqpgPetHmtH26brkoG/W/3YldJ92vfPmlwmwzFz6IshjfNJHLEJEX9a0ZGOupKqHj2MEHZVZPlJc9GSrOy9l29vMQ/XeNN6stz/OVyjchL3LJ6Oc/Oj0PZD2Nsh6ndOTxq0r0xl1PV7C4vdR2but8V7dUdqrk0/XA3Ql6hArxW5fjeoaVIqb1nbdG5DTcgJv1L76rynDlMpATRTYO4RmBS+HPNMZNKT/Bt4VmluSsuRZrPCGATgExz5MdiZLgXhp3e1H3+sD3GOXfFcIpbYSnSA/9O5g6Q7R9CMD7mYS4m/I7VZ0O2eww39sg2scmQ7JL+KpozcYs0gpEo7ojnASub9Opnhpk/VjTnCnyr7nrYvnxMqN+6Zt/eaMXHaJubZR/MIeoB1kXw9ybUfyyZ77uk1U5epcvNS910yc9SZ6Tlu9AKXJw6YP7qQTaX021+PP1u5udysy3NTbZfGEu0vvx1GNycQs0PbdIlG60lHjtrupaRNT7I9qeFzTPGfeoI6lj2/3OoGzIaCgZwJIYjvZCFsacAjsJwFPVZ4EQhwHExHOIz5Xt8DXA8DIetPSGj0Ac4PiqfWIhAEqhfAYbj+MSNXEYBTojaF3FcoUIonwjFEU4YKQHUhxFU3+NQKE8IgENRdXYJDyQH9sUYikMjIh0O1JlxXN8Vd5WC6iNQdXYUdSNI7wyndyICwWIoH5TeOXMcxs3R+10OSu9EsUgGCtA7Q+ldCZcyIgH/YSidaj8UceRDc4jTqSs4Vy60L5xOnUCGUQTlg9KpokR3fQ34IVuj6uNLqgiD6hyj9qXHWUQE4HCUb0hftyv0AoCD8g0qwph5lAAclG9IX8pYNwzg4HwjiGOdDtB3jvINKaUfB9B3h6N8g1O2JjEHzgkc5RsiJl7AKeA/HOUb2sbdkEDfHY7yDW1hTuC7EAd1ThBewIgXQ/OD8h+x5oKyENApR/kPX4dMHwUgfaH8h0fSvA71Hec/oeP73nvz/BsAAP//jJldrhw0DEa3gu4GyJ/tBAFSEttSl1F6+4BEC6pAbJ8MA28T63udkY4yiX3yOTMztWpv3//849+ZP/36/sOn3798+fz1zw/v3/33wR8fv3388P7TW9VczPp++/+L97++ffzlt8+P70qdD44jnDyJW+r1zmkJ4chwGr2NgJMRDqmlPEJOwdZT2XRIwKkIp61GmzoFnAZxbAk7RRxCOGyV3Sw498bYetR6sxlwBOKMoU4ScTq2z+qZpAScAXF640k12p8J1eGoulaO+mJBfZqqDWvRejZ07tpW19kCjiKcxJ32zBxwIP8QTeaVPOBA/uHN5GMF6yHIP9nLGJaDOiTIP3nO4tsjDuif7avv4LwI8k9NnoqniAP5J43WJYccyD91lcZ5RucF+Ud0F6s7qB+C/FP7nDJkBRzIP+Kp1lJywIH8c9Yj5TR9wIH8I+ZsQ6M6hPzDWc79XqL1QP7JqQuzR/sD+adSb97ZAg7knzbqIuIUcCD/1M2nK+rr/emctmIcSTZ9zX7nMOSxlDe1vF+f+5MDeSyJjD7a6z59ciCP0R4tJXp9Lz85kMe4J+2dXucxWtJYsP5qyq1GeQPbnzzt1HMP6hnbnzqplbWDXIftT5vZ/ZFN7hwsZ7KtYRbkZ4Y8T73uquF6IM/nmXrpLfAPYzmTXBtf+uLJgTxf0sijWHBfMFSHaS1LqwceY8jzuW31eumvJwfLmcs3UQl8yJDnadK5Ty/eeHIgz9OyxWtG5wV5XnK3Es65jPmZx16pBhzB5txWspEFc6Vgc24V1eO9gAP5J6vsYTPwmED+oaRGJMG5C+Qf2T3L9KAOBfJPMuKTpYJ8KJh/9rnAXF/fy08O5B8pqe8SeV4g/5wePaM3RfuM+aetrLME3hDIP5XTuS4oqh/MP3wC4pRof7A5N0kevd/rhyfkjZT8TI7l3l88sXwoqw73u+fPEAytJycdNUccLNclzWN1fcnpp0irYfOF122nw15yxDU7lueJjubVX/fpkwPtM9mse/vr+vmXg+Vn0uqW52vOmYQWK9bvvBNVveaoBtZhW6SL0rXfG1iH3JyHyNWHDaxDPjW4ZV37q4F1WEx9lhRxsHunnU6k/rpP+QR9Bt9tVh4peAc464HunTK7yhxXHx4Odu+kWS3d3w8PB6vDoeJlXb1xOFC/8+6d1/2993Agz7c+z6Sr0f6AnictZV7z2OFA/pGUetb7e8vhYPdFaepHigEH6tPUilqJ+nRjferE1jzwz4b6QupYmWvQpxvLmT49cwn6a0P9nqeX8njzvnOgnEnM0uieDw8Hm3OLnXFwB/W8oX4/93cVvv+/czjYe6ZuP3oO6nBjOXNNc53X/HM4UM7k2mifCT7gQP45se4E8RrVD/aeaext3d83DgfyT7WdssjrHPXkQP45l1f2dc/zhwP5h7m0dHY64GD+MbfJfp0LzviO5ahJ0qYGfaqQfzjr2Z4e9Kli75B24rxxsD8K+qfxIIp+F+SfknSP1YL+Usg/bVZdD5ffOZB/6h6PvweDvsBybzNfaVzy/JMD+Sf5Ws3Dc4f8k93EqAb9pdg725lxk7UgRynkn8LDhD06d8g/pT8S4H0+PZzjn38AAAD//4zT3UoEMQwF4FeReYFt2rRJRQemP4F5jHG7F4K7yq7i6+uCXggac9vAR9NzOt+9Q9o/jtv98/F4OL2u4+br4GU7b+u4n0LpzeVI0/dgvJ23h6fDdebDAphan3bzv44TrgElKY5YHHCNKVP/2+nO4sRSMlcQxQGLQ4yQqDjF8ab3cSEUl6LiBNNei/MVAX51EEQoLBYnkOeCvSj3iRbHS4HYQMm9J4uDHmsLXcuLTP3hVBBI24stTvosUMPYFCeb+gO1NxTlf3VTXj7VKuy1HhaT4yItXLPiVFMPm3gJmRWnXZ3dT+iyjsv8AQAA//8DAFBLAwQUAAYACAAAACEAzaerm98CAABGDAAAEgAAAHdvcmQvZm9udFRhYmxlLnhtbMSV3XKiMBSA73dm34HhviUggjq1nW23zuxNL7buA0QIkml+mASrvv2eBFAc1Iq73a1TCSfkM+fLSbh72HDmvBOlqRRT179FrkNEIlMqllP313x2M3IdXWKRYiYFmbpbot2H+69f7taTTIpSOzBe6AlPpm5elsXE83SSE471rSyIgM5MKo5LuFVLj2P1tipuEskLXNIFZbTcegFCkVtj1CUUmWU0Id9lsuJElHa8pwgDohQ6p4VuaOtLaGup0kLJhGgNOXNW8TimYofxww6I00RJLbPyFpKpZ2RRMNxHtsXZHjDsBwg6gCghm36MUc3wYGSbQ9N+nGjHoWmLc91kWoB01QsRDJp5mIsZ3mLptEzzfrhmjTwzFpc4xzo/JGasHzFsEasCYzJ5azNJP2nDHXDLzRryZPJjKaTCCwYkqEoHCsuxYPMN62Mutkk2Nm601I2MmQZYu693rrOeCMwB9LrlC8lsvMBCauJD1zuG7NEQPj4yFR2jCK5DFLueeTDJsdLEMKoHgyqcYU7ZtokqybGoOgpaJnkTf8eKmhyqLk2X0LHSCwSc+s+tIj4cSIeRoPPM4DCSWM7oMOK3noHf9CoBHRFzyol2Xsja+WlnfsyIqZwIDcBECP8BtMLjRuwv/bmRZ5hz8Dyb7Y08QSQeDR87RsbnjNhbv+JcbuQJM7pQ9ISJmTVgPiF4CHqZ0GuqdT8TYccEnNRBGP8TE69E0Qw7j3PrArPyBcLNpOc4h4X9C3WQkgyvWHlsYwzDJo0q+XZidfL1XjmXfDyOw2gcDvbJRzHcP4V27U4l/w3W5PgBEaBH2A5hXQa2FD63CND/3A71Op8TUZ0MRsgni/CPiYhQV0TwkQj/inNBrhQlypyVJ2zEYGJsC8KcEWEvG1ymRB3bHhndkPTyoqjK/PPPSA5H5KmqMG+JqibMW6NfVVz3tkBR20Roz8hdxJgI9nmfNzH+yETd0Pe/AQAA//8DAFBLAwQUAAYACAAAACEAZAMlb1YBAACMAgAAEQAIAWRvY1Byb3BzL2NvcmUueG1sIKIEASigAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfJJfa8IwFMXfB/sOJe9tkladhLbCNnyaMLaOjb2F5FrD2rQk0eq3X1q1TpA95pxzf9w/SRf7ugp2YKxqdIZoRFAAWjRS6TJDH8UynKPAOq4lrxoNGTqARYv8/i4VLRONgVfTtGCcAht4krZMtBnaONcyjK3YQM1t5BPam+vG1Nz5pylxy8UPLwHHhMxwDY5L7jjugWE7EtEJKcWIbLemGgBSYKigBu0sphHFl6wDU9ubBYPzJ1krd2jhZvRsjum9VWOw67qoS4ao75/ir9XL+zBqqHS/KwEoT6VgTrkK8jcQG73VZYpHqTeFAe4akw/y+PBbrbh1K3+AtQL5ePD+Dc1LBnaqP1o+mc2HzCikpx0cqSAD3zs7Tnp2PpOn52KJ8pjQh5DGIZ0UZM6SKSPku2/oqv4CrE8t/EuMZyGZhmRS0Jgl82viGXCc6vr/5L8AAAD//wMAUEsDBBQABgAIAAAAIQDQ1UAi+AEAAA8EAAAQAAgBZG9jUHJvcHMvYXBwLnhtbCCiBAEooAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJxTTW/bMAy9D9h/MHxvFHtdsAWKiiHF0EOLFovbnjWZtoXJkiAxQbJfP8pePGfdab74PZKiHj/Eb469yQ4QonZ2kxeLZZ6BVa7Wtt3kz9XXq095FlHaWhpnYZOfIOY34v07/hSch4AaYkYpbNzkHaJfMxZVB72MC3Jb8jQu9BKJhpa5ptEKbp3a92CRlcvlisERwdZQX/kpYT5mXB/wf5PWTiV98aU6econeAW9NxJBfAPV2b1ts15jdg86IpFo6A+L2uGRsymUVw6lqXQPYknmifAn2UIUHzgbAX91oY7iuvjI2Qj5tpNBKqS2inJV0umZgX/x3mglkTouHrQKLroGs8ehjCwl4Gwewqm0Hah90HhKQuaU32tLCsqCsxGRtiDbIH0XxSoJnBjfKWlgS10RjTQROPtj4Hcg08SfpE4CD7g+gEIXsqh/0szLPPsuI6RebvKDDFpazMewkQzY+IhBVBrBcDbxAc7D5lhfi2IIIHAZOJBBA+FLdXSDgfjYUG34D7HFXOygYZQ6yjmP/43C811/ZX+QlmacHBPaut5LS71nE6Le/4jPvnK3aW9+t/fSOFuJV43dzkuVdmhZfp4vx8zFd2SFmqY9zWsy8DuqLph0AZ21LdTnmLeOtG4v4/sWxWqxpG/Yr7ONlmR6eOIXAAAA//8DAFBLAwQUAAYACAAAACEA3ECOrvUAAABxAQAAEwAIAWRvY1Byb3BzL2N1c3RvbS54bWwgogQBKKAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc0DtvgzAQAOC9Uv+D5d2xoaINCIgaSOYONLtrjoCEH7IvqKjqf6+jNu3e7U53+u5R7t71TBbwYbKmoslGUAJG2X4y54q+dke2pSSgNL2crYGKrhDorr6/K1+8deBxgkAiYUJFR0RXcB7UCFqGTSybWBms1xJj6s/cDsOkoLXqosEgT4V45OoS0Grmfjn67RUL/pfsrbpuF07d6qJXlz/4SgaNU1/RjzZr2jYTGUsPecMSkexZ/pA/MbEVIt2nzTF/PnxS4q7NKSVG6nj6KRKgWkCpxg60myVCxBcs3qyda/QXKPktK/ltaAz/flV/AQAA//8DAFBLAwQUAAYACAAAACEAdD85esIAAAAoAQAAHgAIAWN1c3RvbVhtbC9fcmVscy9pdGVtMS54bWwucmVscyCiBAEooAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIzPsYrDMAwG4P3g3sFob5zcUMoRp0spdDtKDroaR0lMY8tYamnfvuamK3ToKIn/+1G7vYVFXTGzp2igqWpQGB0NPk4Gfvv9agOKxcbBLhTRwB0Ztt3nR3vExUoJ8ewTq6JENjCLpG+t2c0YLFeUMJbLSDlYKWOedLLubCfUX3W91vm/Ad2TqQ6DgXwYGlD9PeE7No2jd7gjdwkY5UWFdhcWCqew/GQqjaq3eUIx4AXD36qpigm6a/XTf90DAAD//wMAUEsBAi0AFAAGAAgAAAAhALDb1V7YAQAATQsAABMAAAAAAAAAAAAAAAAAAAAAAFtDb250ZW50X1R5cGVzXS54bWxQSwECLQAUAAYACAAAACEAmVV+Bf4AAADhAgAACwAAAAAAAAAAAAAAAAARBAAAX3JlbHMvLnJlbHNQSwECLQAUAAYACAAAACEAlyltOWQ9AACVqwIAEQAAAAAAAAAAAAAAAABABwAAd29yZC9kb2N1bWVudC54bWxQSwECLQAUAAYACAAAACEAZdA4hZcBAADbCAAAHAAAAAAAAAAAAAAAAADTRAAAd29yZC9fcmVscy9kb2N1bWVudC54bWwucmVsc1BLAQItABQABgAIAAAAIQC195DVvwIAAPALAAASAAAAAAAAAAAAAAAAAKxHAAB3b3JkL2Zvb3Rub3Rlcy54bWxQSwECLQAUAAYACAAAACEAM21Txb8CAADqCwAAEQAAAAAAAAAAAAAAAACbSgAAd29yZC9lbmRub3Rlcy54bWxQSwECLQAUAAYACAAAACEAidCLEoIDAAASEAAAEAAAAAAAAAAAAAAAAACJTQAAd29yZC9mb290ZXIxLnhtbFBLAQItABQABgAIAAAAIQALmLwNLwQAAFsRAAAQAAAAAAAAAAAAAAAAADlRAAB3b3JkL2hlYWRlcjEueG1sUEsBAi0AFAAGAAgAAAAhACxZUySQAgAA0QoAABAAAAAAAAAAAAAAAAAAllUAAHdvcmQvaGVhZGVyMi54bWxQSwECLQAUAAYACAAAACEAx4t77sMCAABPCwAAEAAAAAAAAAAAAAAAAABUWAAAd29yZC9mb290ZXIyLnhtbFBLAQItABQABgAIAAAAIQCeKX9oNw4AANsYAQARAAAAAAAAAAAAAAAAAEVbAAB3b3JkL2NvbW1lbnRzLnhtbFBLAQItABQABgAIAAAAIQBg/7/1AAYAAKIbAAAVAAAAAAAAAAAAAAAAAKtpAAB3b3JkL3RoZW1lL3RoZW1lMS54bWxQSwECLQAUAAYACAAAACEAbSNutDAVAAAbZQAAEQAAAAAAAAAAAAAAAADebwAAd29yZC9zZXR0aW5ncy54bWxQSwECLQAUAAYACAAAACEAVkSyEvQAAAB0AQAAHAAAAAAAAAAAAAAAAAA9hQAAd29yZC9fcmVscy9zZXR0aW5ncy54bWwucmVsc1BLAQItABQABgAIAAAAIQC38a4krwAAAA4BAAATAAAAAAAAAAAAAAAAAGuGAABjdXN0b21YbWwvaXRlbTEueG1sUEsBAi0AFAAGAAgAAAAhAOj6rcPiAAAAVQEAABgAAAAAAAAAAAAAAAAAc4cAAGN1c3RvbVhtbC9pdGVtUHJvcHMxLnhtbFBLAQItABQABgAIAAAAIQBIqXUZAAcAAFAyAAASAAAAAAAAAAAAAAAAALOIAAB3b3JkL251bWJlcmluZy54bWxQSwECLQAUAAYACAAAACEAfUiQTTQUAABlugAADwAAAAAAAAAAAAAAAADjjwAAd29yZC9zdHlsZXMueG1sUEsBAi0AFAAGAAgAAAAhACDDsdZqAgAAeBUAABQAAAAAAAAAAAAAAAAARKQAAHdvcmQvd2ViU2V0dGluZ3MueG1sUEsBAi0AFAAGAAgAAAAhADCUfuAHBwAAYy0AABkAAAAAAAAAAAAAAAAA4KYAAHdvcmQvY29tbWVudHNFeHRlbmRlZC54bWxQSwECLQAUAAYACAAAACEAEEBv9okJAADbOwAAFAAAAAAAAAAAAAAAAAAergAAd29yZC9jb21tZW50c0lkcy54bWxQSwECLQAUAAYACAAAACEAzaerm98CAABGDAAAEgAAAAAAAAAAAAAAAADZtwAAd29yZC9mb250VGFibGUueG1sUEsBAi0AFAAGAAgAAAAhAGQDJW9WAQAAjAIAABEAAAAAAAAAAAAAAAAA6LoAAGRvY1Byb3BzL2NvcmUueG1sUEsBAi0AFAAGAAgAAAAhANDVQCL4AQAADwQAABAAAAAAAAAAAAAAAAAAdb0AAGRvY1Byb3BzL2FwcC54bWxQSwECLQAUAAYACAAAACEA3ECOrvUAAABxAQAAEwAAAAAAAAAAAAAAAACjwAAAZG9jUHJvcHMvY3VzdG9tLnhtbFBLAQItABQABgAIAAAAIQB0Pzl6wgAAACgBAAAeAAAAAAAAAAAAAAAAANHCAABjdXN0b21YbWwvX3JlbHMvaXRlbTEueG1sLnJlbHNQSwUGAAAAABoAGgCeBgAA18QAAAAA # Invoice licenses and service contracts # def before_report(context): # Get the logo from the system settings for the letterhead logo = vtcapp.getpropertyvalue("CompanyLogo") context.set_image("logo", logo) class VATRate(Table): fields=[ CurrencyField("betrag"), CurrencyField("mwst"), CurrencyField("mwstsatz"), ] class Licenses(Table): fields=[ OclTextField("periodtext", "keystring('periodText')"), OclTextField("text"), OclCurrencyField("anzahl", "if ((quantity>0) and (not (discountAmount>0))) then quantity*100->round/100 else quantity.asnull endif"), OclCurrencyField("stueckpreis", "if ((feePerUnitExt>0) and (not (discountAmount>0))) then feePerUnitExt else feePerUnitExt.asnull endif"), OclBooleanField("is_serviceVertrag", "getlinks('LnkAuslageAuslagetypphaselink_A').oclastype(Auslagetypphaselink)->select(hastag('servicecontract'))->size>0"), OclCurrencyField("auslagenext", "wertext") ] class PhaseSum(Table): fields=[ TextField("phase"), MinuteField("aufwand"), CurrencyField("honorar"), FrameField("lizenzen", Licenses), ] class Invoice(Table): businessclass = "Invoice" fields = [ # Header OclTextField("projektleiter", "project.projectmanager.correspondenceName"), OclTextField("email", "TimSession.allinstances->first.login.briefemail"), OclTextField("anrede", "invoiceSalutation"), OclBooleanField("is_DE", "companyCountry = 'Deutschland'"), OclBooleanField("has_periode", "(startdate.asstring<>'') or (enddate.asstring<>'')"), OclTextField("projektbetreff", "projekt.betreffend"), OclTextField("bic", "projekt.zahlungstyp.oclasType(ZahlungsTyp).bic"), # Own company informations from invoice OclTextField("absender", "companyName"), OclTextField("absender_adresse", "companyStreetaddress"), OclTextField("absender_plz", " companyZIPCode"), OclTextField("absender_ort", "companyCity"), OclTextField("absender_telefon", "companyAddress.standardTelephone"), OclTextField("mwstlabel", "if companyCountry = 'Österreich' then 'UID' else if companyCountry = 'Deutschland' then 'USt-IdNr' else 'MwSt-Nr' endif endif"), OclTextField("mwstnr", "companyVATID"), # Summary TableField("phasesums", PhaseSum, "calc_phasesums"), OclBooleanField("show_leistungstotal", "(not fixedPriceServices) and (totalFeeServicesExt<>0)"), OclCurrencyField("rproz", "discountPercent/100"), OclCurrencyField("sproz", "fixedPriceExpensesPercent/100"), OclBooleanField("show_spesenext", "(useExpenses) and (totalFeeExpensesExt-fixedPriceExpensesAmountEff>0)"), OclCurrencyField("spesenext", "totalFeeExpensesExt-fixedPriceExpensesAmountEff"), OclCurrencyField("auslagenext", "outlays->select((type.customfieldint('lic_kindOfOutlayType')=0) or (type.customfieldint('lic_kindOfOutlayType')>2)).feeExt->sum"), OclTableField("lizenzen", "Licenses", "outlays->select((type.customfieldint('lic_kindOfOutlayType')=1) or (type.customfieldint('lic_kindOfOutlayType')=2))"), TextField("advancesText"), OclBooleanField("has_excl", "(totalVATServices+totalVATExpenses+totalVATOutlays+totalVATDownpaymentCharged)<>0"), OclCurrencyField("leistspesenextmitmwst", "totalFeeServicesExtAfterDiscount+totalFeeExpensesExt+totalFeeOutlaysExt+totalDownpaymentCharged"), TableField("mwsttypen", VATRate, "calc_vatrates"), OclBooleanField("has_subtotal", "((totalVATServices+totalVATExpenses+totalVATOutlays+totalVATDownpaymentCharged)<>0) and (totalDownpaymentDeducted<>0)"), OclCurrencyField("totalvorabzugvorschuesse", "totalFeeServicesExpensesExtWithVAT+totalDownpaymentCharged+totalVATDownpaymentCharged"), OclCurrencyField("vmwst", "totalVATDownpaymentDeducted"), OclCurrencyField("vorschusseffektivmitmwst", "-totalVATDownpaymentDeducted"), OclBooleanField("inclmwst", "((totalVATServices+totalVATExpenses+totalVATOutlays+totalVATDownpaymentCharged)<>0)"), # Conditions OclTextField("konto", "if besrBank<>'' then 'Konto '+bankCustomerNum else 'PC '+esrTeilnehmer endif"), OclBooleanField("is_EUR", "currency.asString = 'EUR'"), # QR BooleanField("show_swissqr"), OclTextField("rech_adresstext", "qrInvoiceAddressText"), OclTextField("absender_QRAdressText", "qrCompanyAdresstext"), OclTextField("qrbillinginfo", "qrBillingInformation"), ] def initialize_row(context, row): invoice = context.varInvoice row.advancesText = context.translate("Advances") # If there is only one advance, display the designation # of the advance directly on the cover sheet if context.evalocl("downpaymentsToCharge->size = 1"): row.advancesText = context.evalocl("downpaymentsToCharge->first.Designation") # The page with the Swiss QR code will be displayed only if the IBAN contains a CH or LI number row.show_swissqr = (invoice.iban[0:2] in ("LI","CH")) def calc_phasesums(context): """ Calculate PhaseSums for Services """ phasentotale = context.evalocl("phaseTotals->select(totalFeeServicesExt<>0)->orderby(phase.orderIdx)") for phasentotal in phasentotale: phaseRow = context.table.add_row() phaseRow.phase = phasentotal.evalocl("if phase.description<>'' then phase.description else phase.code endif") phaseRow.aufwand = phasentotal.evalocl("if phase.fixedPriceServices then VtcCurrency.null else services.minutesExt->sum endif") phaseRow.honorar = phasentotal.totalFeeServicesExt phaseRow.auslagenext = phasentotal.evalocl("outlays->reject((type.customfieldint('lic_kindOfOutlayType')=1) or (type.customfieldint('lic_kindOfOutlayType')=2)).feeExt->sum") phaseRow.lizenzen = Licenses(context, phasentotal.evalocl("outlays->select((type.customfieldint('lic_kindOfOutlayType')=1) or (type.customfieldint('lic_kindOfOutlayType')=2))")) def calc_vatrates(context): """ Get vat rates from services, expenses, outlays and downpayments """ vat_rates = context.evalocl("serviceTotals->union(expenseTotals)->union(outlayTotals).vatRate") # append saetze from Vorschuesse vat_rates += context.evalocl("downpaymentsToCharge.vatRate") # make a list of unique rates vat_rates = set(vat_rates) for satz in sorted(vat_rates): vat_row = context.table.add_row() vat_row.mwstsatz = satz/100 vat_row.betrag = context.evalocl("""outlayTotals->select(vatRate = {0})->union((expenseTotals) ->select(vatRate = {0})).feeExt->sum+((serviceTotals) ->select(vatRate = {0})).feeExtDiscount->sum+downpaymentsToCharge ->select(vatRate = {0}).amountNet->sum""".format(satz)) vat_row.mwst = context.evalocl("""outlayTotals->select(vatRate = {0})->union((expenseTotals) ->select(vatRate = {0})).vatAmount->sum+((serviceTotals) ->select(vatRate = {0})).vatAmountDiscount->sum+downpaymentsToCharge ->select(vatRate = {0}).vatAmount->sum""".format(satz)) false ReportQuoteLicensesAndServiceContracts false true %dokpfad%\%nummer% PDF true false false 0 Offer licences and service contracts 0 true false Offer true true false Offer.docx DE 0 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 # Offer # def before_report(context): # Get the logo from the system settings for the letterhead logo = vtcapp.getpropertyvalue("CompanyLogo") context.set_image("logo", logo) class ServicetypePhaseLink(Table): businessclass = "ServicetypePhaseLink" fields = [ OclTextField("text", "if offertext.asstring='' then servicetype.text else offertext endif"), ] class OutlaytypePhaseLink(Table): businessclass = "OutlaytypePhaseLink" fields = [ OclTextField("text", "if offertext='' then outlaytype.text else offertext endif"), OclCurrencyField("anzahl", "customfieldcurr('lic_amount')->collect(a| if a > 0 then a else a.asNull endif)->first"), OclCurrencyField("preisOrg", "feePerUnitExt->collect(a| if a > 0 then a else a.asNull endif)->first"), OclCurrencyField("stueckpreis", "feePerUnitExt->collect(a| if a > 0 then if self.customfieldcurr('lic_discount')>0 then a-self.customfieldcurr('lic_discount') else a endif else a.asNull endif)->first"), OclCurrencyField("planwertOrg", "customfieldcurr('lic_amount')*feePerUnitExt"), OclBooleanField("has_rabatt", "customfieldcurr('lic_discount')>0"), OclBooleanField("has_rabattProzent", "customfieldcurr('lic_discountPercentage')>0"), OclBooleanField("has_rabattBetrag", "(customfieldcurr('lic_discount')>0) and (customfieldcurr('lic_discountPercentage').isNull or (customfieldcurr('lic_discountPercentage')=0))"), OclCurrencyField("rproz", "customfieldcurr('lic_discountPercentage')/100"), OclCurrencyField("rabattbetrag", "customfieldcurr('lic_discount')"), OclDateField("startdatum", "customfielddate('lic_startDate')"), OclTextField("abrechnungsintervall", "customfieldAsString('lic_accountingInterval')"), OclBooleanField("is_licbetrag", "customfieldbool('lic_calcPrice')"), OclCurrencyField("licproz", "keycurr('licpercent')*100"), OclCurrencyField("licbetrag", "keycurr('lictotal')"), ] class ExpensetypePhaseLink(Table): businessclass = "ExpensetypePhaseLink" fields = [ OclTextField("text", "if offertext='' then expensetype.text else offertext endif"), ] class Interval(Table): fields = [ TableField("vertraege", OutlaytypePhaseLink), BooleanField("has_intervallSumme"), TextField("abrechnungsintervall") ] class Phase(Table): businessclass = "Phase" fields = [ # Must declare the x-Fields here, otherwise they're not available # as Cond-Expression since I don't show them in the report. OclCurrencyField("xPlanFeeServicesExt"), OclCurrencyField("xPlanFeeExpensesExt"), OclCurrencyField("xPlanFeeOutlaysExt"), OclCurrencyField("total", "planFeeServicesExt+ planFeeOutlaysExt+ planFeeExpensesExt-outlaytypelinks->select(outlaytype.customfieldint('lic_kindOfOutlayType')=2).planFeeOutlaysExt->sum"), # Show ProjekteintragPhaseLinks values only # if the plan value on the phase is not overridden. OclTableField("taetigkeiten", ServicetypePhaseLink, "self->select(xPlanFeeServicesExt.isNull).servicetypelinks->orderby(asstring)"), OclTableField("spesentypen", ExpensetypePhaseLink, "self->select(xPlanFeeExpensesExt.isNull).expensetypelinks->orderby(asstring)"), OclTableField("auslagetypen", "OutlaytypePhaseLink", "outlaytypelinks->select((outlaytype.customfieldint('lic_kindOfOutlayType')=0) or (outlaytype.customfieldint('lic_kindOfOutlayType')>=3))"), OclTableField("lizenzen", "OutlaytypePhaseLink", "outlaytypelinks->select(outlaytype.customfieldint('lic_kindOfOutlayType')=1)"), TableField("intervalle", "Interval", "calc_interval"), ] def calc_interval (context): """ Calculate the interval for the quote """ intervalle = context.evalocl("self.outlaytypelinks->select(outlaytype.customfieldint('lic_kindOfOutlayType')=2)->select(customfieldint('lic_accountingInterval').notNull).customfieldint('lic_accountingInterval')->asset") table = Interval(context) for interval in intervalle: row = table.add_row(interval) vertraege = context.evalocl("self.outlaytypelinks->select(outlaytype.customfieldint('lic_kindOfOutlayType')=2)->select(customfieldint('lic_accountingInterval')={})->orderby(customfielddate('lic_startdate'))".format(interval)) row.vertraege = OutlaytypePhaseLink(context, vertraege) if len(vertraege) >= 2: row.has_intervallSumme = True else: row.has_intervallSumme = False vertrag = vertraege[0] intervallText = vertrag.evalocl("customfieldAsString('lic_accountingInterval')") charging_type = vertrag.evalocl("customfieldAsString('lic_charge_type')") row.abrechnungsintervall = "{}, {}: {}".format(intervallText, vtcapp.translate('Charge type'), charging_type) return table class Offer(Table): businessclass = "Offer" fields = [ TextField("absender"), TextField("absender_adresse"), TextField("absender_plz"), TextField("absender_ort"), TextField("absender_telefon"), OclTextField("adresstext", "project.customer.addresstext"), OclTextField("briefanrede", "project.customer.salutation"), OclTextField("grussformel", "project.customer.complimentaryClose"), OclTextField("projektleiter", "project.projectmanager.correspondenceName"), OclTextField("email", "project.projectmanager.correspondenceEmail"), OclTextField("projektbetreff", "project.regarding"), OclCurrencyField("total", "phases.planFeeServicesExt->sum + phases.planFeeOutlaysExt->sum + phases.planFeeExpensesExt->sum - phases.outlaytypelinks->select(outlaytype.customfieldint('lic_kindOfOutlayType')=2).planFeeOutlaysExt->sum"), OclTextField("waehrung", "project.currency"), # List only phases that have planned values OclTableField("phasen", Phase, "phases->select((planFeeServicesExt + planFeeOutlaysExt + planFeeExpensesExt) > 0)->orderby(orderIdx)"), ] def initialize_row(context, row): # Get the company address from the system settings and set the values. absender = vtcapp.getpropertyvalue('Firma') if absender: row.absender = absender.evalocl("self.asstring") row.absender_adresse = absender.standardStreetaddress row.absender_plz = absender.standardZipCode row.absender_ort = absender.standardCity row.absender_telefon = absender.standardTelephone false ClassSettingsAuslagentypZuordnung Standard function links an outlay type to a phase. Additionally, this represents a license sale or service contract on a phase. <!-- Only show default page if no license sales and no service contract --> <Page Override="OutlayBaseTypePhaseLink" VisibleExpression="not hastag('license') and not hastag('servicecontract')" > <OutlayTypeComboBox Override="PurchaseType" Label="{Translate 'Purchase type'}" ValueExpression="outlaytype" ListExpression="Auslagetyp.allinstances->select(aktiv)->select(zusatzfeldint('lic_kindOfOutlayType')=0)" WidthFraction="0.5" /> </Page> <!-- Page override for Licenses --> <Page Name="License" PlaceBefore="OutlayBaseTypePhaseLink" VisibleExpression="hastag('license')" Header="{Translate 'License sale'}"> <!-- We use our own groups so disable following builtIn groups --> <Group Override="RatesGroup" Visible="False" /> <Group Override="PurchaseGroup" Visible="False" /> <Group Name="General" PlaceBefore="PurchaseGroup" > <OutlayTypeComboBox Name="LicenseSale" Label="{Translate 'License sale'}" ValueExpression="auslagetypen" ListExpression="Auslagetyp.allinstances->select(aktiv)->select(zusatzfeldint('lic_kindOfOutlayType')=1)" /> <!-- Only show manufacturer if there is a product assigned to license, else show spacer --> <TextBlock Name="Manufacturer" ShowLabel="True" Label="{Translate 'Manufacturer'}" ValueExpression="auslagetypen.zusatzfeldobj('lic_product')->oclAsType(ConfigSetCustomClass26).zusatzfeldasstring('cc26_licManufacturer')" VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').notNull" /> <Spacer VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').isNull" /> </Group> <Group Name="SupplierAndProduct" PlaceAfter="PurchaseGroup" > <AddressReferenceBox Name="Supplier" Label="{Translate 'Supplier'}" ValueExpression="zusatzfeldobj('lic_supplier')" /> <!-- Only show product if there is a product assigned to license, else show spacer --> <TextBlock Name="Product" ShowLabel="True" Label="{Translate 'Product'}" ValueExpression="auslagetypen.zusatzfeldobj('lic_product')" VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').notNull" /> <Spacer VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').isNull" /> </Group> <TextBox Override="Designation" Label="{Translate 'Designation'}" ValueExpression="designation" /> <!-- For QuoteText we override the translation, as we use offer instead of quote--> <TextBox Override="QuoteText" Label="{Translate 'Offer text'}" ValueExpression="offerText"/> <Group Name="Rates" PlaceAfter="QuoteText" Orientation="Vertical"> <Group Name="Price" Header="{Translate 'Rates'}" Orientation="Vertical" > <Group> <TextBox Name="PurchasePrice" Label="{Translate 'Purchase price'}" ValueExpression="wertProEinheitInt" ContentAlignment="Right" /> <TextBox Name="UnitValue" Label="{Translate 'Unit value (costs)'}" ValueExpression="wertproeinheitkosten" ContentAlignment="Right" /> </Group> <TextBox Name="SellingPrice" Label="{Translate 'Selling price'}" ValueExpression="wertProEinheitExt" ContentAlignment="Right" WidthFraction="0.5" /> <Group> <TextBox Name="DiscountPercent" Label="{Translate 'Discount %'}" ValueExpression="zusatzfeldcurr('lic_discountPercentage')" ContentAlignment="Right"/> <TextBox Name="DiscountAmount" Label="{Translate 'Discount amount'}" ValueExpression="zusatzfeldcurr('lic_discount')" ContentAlignment="Right"/> </Group> <TextBlock Name="PriceInclDiscount" ShowLabel="True" WidthFraction="0.5" Label="{Translate 'Price incl. discount'}" ValueExpression="wertproeinheitext - zusatzfeldcurr('lic_discount')" ContentAlignment="Right"/> </Group> <Group Name="Sales" Header="{Translate 'Sales'}" PlaceAfter="Rates"> <TextBox Name="LicAmount" Label="{Translate 'Quantity'}" ValueExpression="zusatzfeldcurr('lic_amount')" ContentAlignment="Right"/> <TextBox Name="ShowTotal1" Label="{Translate 'Total'}" IsLabelBold="True" ValueExpression="planWertAuslagen" ContentAlignment="Right" /> </Group> </Group> <Group Name="Dates" PlaceAfter="Rates" Separator="Always" VisibleExpression="hastag('license')" > <DatePicker Name="PurchaseDate" Label="{Translate 'Purchase date'}" ValueExpression="zusatzfelddate('lic_startDate')" WidthFraction="0.5" /> </Group> </Page> <!-- Page override for Service contracts. As names must be unique we add for (reused) names the extension "SC": name->nameSC --> <Page Name="ServiceContract" PlaceBefore="OutlayBaseTypePhaseLink" VisibleExpression="hastag('servicecontract')" Header="{Translate 'Service contract'}" LabelWidth = "115" > <!-- We use our own goups so disable following builtIn groups --> <Group Override="RatesGroup" Visible="False" /> <Group Override="PurchaseGroup" Visible="False" /> <Group Name="GeneralSC" PlaceBefore="PurchaseGroup" > <OutlayTypeComboBox Name="ServiceContractSC" Label="{Translate 'Service contract'}" ValueExpression="auslagetypen" ListExpression="Auslagetyp.allinstances->select(aktiv)->select(zusatzfeldint('lic_kindOfOutlayType')=2)" /> <!-- Only show manufacturer if there is a product assigned to license, else show spacer --> <TextBlock Name="ManufacturerSC" ShowLabel="True" Label="{Translate 'Manufacturer'}" ValueExpression="auslagetypen.zusatzfeldobj('lic_product')->oclAsType(ConfigSetCustomClass26).zusatzfeldasstring('cc26_licManufacturer')" VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').notNull" /> <Spacer VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').isNull" /> </Group> <Group Name="SupplierAndProductSC" PlaceAfter="PurchaseGroup" > <AddressReferenceBox Name="SupplierSC" Label="{Translate 'Supplier'}" ValueExpression="zusatzfeldobj('lic_supplier')" /> <TextBlock Name="ProductSC" ShowLabel="True" Label="{Translate 'Product'}" ValueExpression="auslagetypen.zusatzfeldobj('lic_product')" VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').notNull" /> <Spacer VisibleExpression="auslagetypen.zusatzfeldobj('lic_product').isNull" /> </Group> <TextBox Override="Designation" Label="{Translate 'Designation'}" ValueExpression="designation" /> <!-- For QuoteText we override the translation, as we use offer instead of quote--> <TextBox Override="QuoteText" Label="{Translate 'Offer text'}" ValueExpression="offerText"/> <Group Name="CalcPrice" Orientation="Vertical" Separator="Always" PlaceBefore="RatesGroup" > <Group> <CheckBox Name="CalculatePrice" ShowLabel="True" Label="{Translate 'Calculate price'}" ValueExpression="zusatzfeldbool('lic_calcPrice')"/> <!-- Button only has a (script)function, if outlaytype is assigned --> <ScriptButton Name="CalculateButton" Width="146" HorizontalAlignment="Right" Text="{Translate 'Select licences'}" ScriptName="calculate_price_from_licenses" Appearance="Input" VisibleExpression="zusatzfeldbool('lic_calcPrice') and auslagetypen.notNull"/> <ScriptButton Name="CalculateButtonDisabled" Width="146" HorizontalAlignment="Right" Text="{Translate 'Select licenses'}" ScriptName="" Appearance="Input" VisibleExpression="zusatzfeldbool('lic_calcPrice') and auslagetypen.isNull"/> </Group> <TextBox Name="ServiceContractText" ShowLabel="True" Label="{Translate 'Calculation'}" ValueExpression="keystring('lic_textLicenses')" VisibleExpression="zusatzfeldbool('lic_calcPrice') and not (keystring('lic_textLicenses')='')"/> </Group> <Group Name="RatesSC" PlaceAfter="RatesGroup" Orientation="Vertical" VisibleExpression="not zusatzfeldbool('lic_calcPrice')" > <Group Name="PriceSC" Header="{Translate 'Rates'}" Orientation="Vertical" > <Group> <TextBox Name="PurchasePriceSC" Label="{Translate 'Purchase price'}" ValueExpression="wertProEinheitInt" ContentAlignment="Right" /> <TextBox Name="UnitValueSC" Label="{Translate 'Unit value (costs)'}" ValueExpression="wertproeinheitkosten" ContentAlignment="Right" /> </Group> <TextBox Name="SellingPriceSC" Label="{Translate 'Selling price'}" ValueExpression="wertProEinheitExt" ContentAlignment="Right" WidthFraction="0.5" /> <Group> <TextBox Name="DiscountPercentSC" Label="{Translate 'Discount %'}" ValueExpression="zusatzfeldcurr('lic_discountPercentage')" ContentAlignment="Right"/> <TextBox Name="DiscountAmountSC" Label="{Translate 'Discount amount'}" ValueExpression="zusatzfeldcurr('lic_discount')" ContentAlignment="Right"/> </Group> <TextBlock Name="PriceInclDiscountSC" ShowLabel="True" WidthFraction="0.5" Label="{Translate 'Price incl. discount'}" ValueExpression="wertproeinheitext - zusatzfeldcurr('lic_discount')" VisibleExpression="not zusatzfeldbool('lic_calcPrice')" ContentAlignment="Right"/> </Group> <Group Name="Total" Header="{Translate 'Sales'}" > <TextBox Name="LicAmountSC" Label="{Translate 'Quantity'}" ValueExpression="zusatzfeldcurr('lic_amount')" ContentAlignment="Right"/> <TextBox Name="ShowTotalSC" Label="{Translate 'Total'}" IsLabelBold="True" ValueExpression="planWertAuslagen" ContentAlignment="Right" /> </Group> </Group> <Group Name="TotalCalculated" PlaceAfter="RatesGroup" Orientation="Vertical" VisibleExpression="zusatzfeldbool('lic_calcPrice')" > <Spacer Height="3" /> <Group> <Spacer/> <TextBox Name="ShowTotal" Label="{Translate 'Total'}" IsLabelBold="True" ValueExpression="planWertAuslagen" ContentAlignment="Right" /> </Group> </Group> <!-- After created the first invoice, the date/period parameters can not longer be changed Therefore we have two almost identical groups (DatesBeforeInvoicing/DatesAfterInvoicing) --> <Group Name="DatesBeforeInvoicing" PlaceAfter="Rates" Orientation="Vertical" VisibleExpression="self->getLinks('LnkAuslageAuslagetypphaselink_B')->size=0"> <Group Name="InvoicingInformationA1" Separator="Always" > <DatePicker Name="StartDateA" Label="{Translate 'Start date'}" ValueExpression="zusatzfelddate('lic_startDate')" /> <AdditionalFieldComboBox Name="AccountingIntervalA" Label="{Translate 'Invoice period'}" ValueExpression="zusatzfeldint('lic_accountingInterval')"/> </Group> <Group Name="InvoicingInformationA2" > <TextBlock Name="NextInvoicingDateA" Label="{Translate 'Next invoicing'}" ShowLabel="True" ValueExpression="zusatzfelddate('lic_nextInvoicingDate').asstring" /> <AdditionalFieldComboBox Name="ChargetypeA" Label="{Translate 'Charge type'}" ValueExpression="zusatzfeldint('lic_charge_type')" /> </Group> </Group> <Group Name="DatesAfterInvoicing" PlaceAfter="Rates" Orientation="Vertical" VisibleExpression="self->getLinks('LnkAuslageAuslagetypphaselink_B')->size&gt;0"> <Group Name="InvoicingInformationB1" Separator="Always" > <DatePicker Name="StartDateB" Label="{Translate 'Start date'}" ValueExpression="zusatzfelddate('lic_startDate')" IsReadOnly="True"/> <AdditionalFieldComboBox Name="AccountingIntervalB" Label="{Translate 'Invoice period'}" ValueExpression="zusatzfeldint('lic_accountingInterval')" IsReadOnly="True"/> </Group> <Group Name="InvoicingInformationB2" > <TextBlock Name="NextInvoicingDateB" Label="{Translate 'Next invoicing'}" ShowLabel="True" ValueExpression="zusatzfelddate('lic_nextInvoicingDate').asstring" /> <AdditionalFieldComboBox Name="ChargetypeB" Label="{Translate 'Charge type'}" ValueExpression="zusatzfeldint('lic_charge_type')" IsReadOnly="True"/> </Group> </Group> <Group Name="CancellationSC" PlaceAfter="Rates" Orientation="Vertical" > <Group Name="ServiceContractInfos" Separator="Always" > <TextArea Name="NoticePeriod" Label="{Translate 'Notice period'}" Lines ="1" ValueExpression="zusatzfeld('lic_noticePeriod')" /> </Group> <Group Name="Cancellation" > <DatePicker Name="CancelationDate" Label="{Translate 'Cancellation date_lic'}" ValueExpression="zusatzfelddate('lic_cancellationDate')" /> <DatePicker Name="EndDate" Label="{Translate 'End date'}" ValueExpression="zusatzfelddate('lic_endDate')" /> </Group> </Group> </Page> OutlaytypePhaseLink if auslagetypen.zusatzfeldint('lic_kindOfOutlayType') = 1 then 'License sale'.translate else if auslagetypen.zusatzfeldint('lic_kindOfOutlayType') = 2 then 'Service contract'.translate else 'Outlay type allocation' endif endif 17 true true OutlaytypePhaseLink 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 10 false customfieldcurr('lic_discountPercentage') false 0 Discount % true 70 false false false 1 11 true customfieldcurr('lic_discount') false 0 Discount amount true 70 false false false 1 12 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 13 clgreen false '' false 0 true 3 false false false 1 14 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 15 false planFeeOutlaysExt false 0 Total true 60 false false false 0 16 clGreen false '' false 0 true 3 false false false 0 17 false <DatePicker/> customfielddate('lic_startDate') false 0 Start date true 60 false false false 0 18 if customfielddate('lic_endDate').notNull then 'clYellow' else '' endif false customfielddate('lic_endDate') false 0 End date true 73 false false false 0 19 cmbzusatzfeld rndzusatzfeld false customfieldint('lic_accountingInterval') false 0 Invoice period true 100 false false false 0 2 cmbTyp false <ComboBox Override="cmbTyp" ShowNavLinkButton="True" ListExpression="Auslagetyp.allinstances->select(aktiv)->select(zusatzfeldint('lic_kindOfOutlayType')=2)" GhostrowListExpression="Auslagetyp.allinstances->select(aktiv)->select(zusatzfeldint('lic_kindOfOutlayType')=2)" /> outlaytype false 0 Purchase type true 100 false false false 0 20 false customfielddate('lic_nextInvoicingDate') false 0 Next invoicing true 106 false false false 0 21 false getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Auslage).rechnung->orderby(datum)->last.datum false 0 Date of last invoice true 115 false false false 1 22 false getlinks('LnkAuslageAuslagetypphaselink_B') ->oclastype(Outlay).feeext->sum false 0 Charged true 60 false false false 0 3 false outlaytype.customfieldasstring('lic_product') false 0 Product true 80 false false false 0 4 false designation false 0 Designation true 120 false false false 0 5 clGreen false '' false 0 true 3 false false false 0 6 false phase.owningproject.currency false 0 Currency true 60 false false false 1 7 false feePerUnitInt false 0 Purchase price true 80 false false false 1 8 false outlaytype.feePerUnitExt true 0 List selling price true 95 false false false 1 9 false feePerUnitExt false 0 Selling price true 70 false false false ClassSettingsAuslageTyp <Page Override="OutlayBaseType"> <AddressReferenceBox Name="OutlayBaseTypeLicenseSupplier" Label="{Translate 'Supplier'}" ValueExpression="zusatzfeldobj('lic_supplier')" PlaceAfter="Text" VisibleExpression="(zusatzfeldint('lic_kindOfOutlayType')=1) or (zusatzfeldint('lic_kindOfOutlayType')=2)" WidthFraction="0.75"/> <AdditionalFieldComboBox Name="OutlayBaseTypeLicenseProduct" Label="{Translate 'Product'}" ValueExpression="zusatzfeldobj('lic_product')" ShowRemoveButton="True" PlaceAfter="Text" VisibleExpression="(zusatzfeldint('lic_kindOfOutlayType')=1) or (zusatzfeldint('lic_kindOfOutlayType')=2)" WidthFraction="0.75"/> <Group Name="OutlayBaseTypePlaceAfter" PlaceAfter="Text"> <AdditionalFieldComboBox Name="OutlayBaseTypePlaceAfterKindPurchaseType" ValueExpression="zusatzfeldint('lic_kindOfOutlayType')" Label="{ Translate 'Kind purchase type'}" FlexWidth="3"/> <Spacer Name="OutlayBaseTypePlaceAfterSpacer" /> </Group> <Group Name="OutlayBaseTypeMarginVertical" PlaceBefore="MarginValue" Orientation="Vertical" VisibleExpression="zusatzfeldint('lic_kindOfOutlayType')=2" > <TextArea Name="OutlayBaseTypeMarginVerticalNoticePeriod" Label="{Translate 'Notice period'}" Lines="2" ValueExpression="zusatzfeld('lic_noticePeriod')" WidthFraction="0.75"/> <AdditionalFieldComboBox Name="OutlayBaseTypeMarginVerticalInvoicePeriod" Label="{Translate 'Invoice period'}" ValueExpression="zusatzfeldint('lic_accountingInterval')" WidthFraction="0.75"/> <AdditionalFieldComboBox Name="ChargeType" Label="{Translate 'Charge type'}" ValueExpression="zusatzfeldint('lic_charge_type')" WidthFraction="0.75"/> </Group> <Group Name="OutlayBaseTypeAfterUnitValueCost" PlaceAfter="UnitValueCost"> <TextBox Name="OutlayBaseTypeAfterUnitValueCostPercentageOfSoldLicenses" Label="{Translate '% of license total'}" ValueExpression="zusatzfeldcurr('lic_percentageOfSoldLicenses')" ContentAlignment="Right" VisibleExpression="(zusatzfeldint('lic_kindOfOutlayType')=2)"/> <CheckBox Name="OutlayBaseTypeAfterUnitValueCostConsiderDiscounts" ShowLabel="False" Text="{Translate 'Consider discounts'}" ValueExpression="zusatzfeldbool('lic_calcInclDiscount')" VisibleExpression="(zusatzfeldint('lic_kindOfOutlayType')=2)"/> </Group> <TextBox Name="OutlayBaseTypeMarginVerticalMarginValuePurchaseType" Override="MarginValue" VisibleExpression="(zusatzfeldint('lic_kindOfOutlayType')=0) or (zusatzfeldint('lic_kindOfOutlayType')>2)"/> </Page> Outlaytype 17 true true Outlaytype 0 0 false code false 1 Code true 156 false false false 0 1 false text false 0 Text current language true 122 false false false 0 2 cmbzusatzfeld rndzusatzfeld false zusatzfeldint('lic_kindOfOutlayType') false 0 Kind purchase type true 100 false false false 0 3 cmbzusatzfeld rndzusatzfeld false if (zusatzfeldint('lic_kindOfOutlayType') = 1) or (zusatzfeldint('lic_kindOfOutlayType') = 2) then zusatzfeldobj('lic_product') else zusatzfeldobj('lic_product').asNull endif false 0 Licensed product true 85 false false false 0 4 clGreen false '' false 0 true 3 false false false 1 5 false wertproeinheitint false 0 Unit value internal true 85 false false false 1 6 false wertproeinheitext false 0 Unit value external true 85 false false false 0 7 clGreen false '' false 0 true 3 false false false 0 8 false bemerkung false 0 Remark true 200 false false false ClasssettingsConfigsetcustomclass26Lizenzprodukt Represents a license product, including the product name and the manufacturer. zusatzfeld('cc26_licProductname') ConfigSetCustomClass26 'Lizenzprodukt' 17 true true ConfigSetCustomClass26 0 1 false zusatzfeld('cc26_licProductname') false 1 Name true 150 false false false 0 2 false zusatzfeld('cc26_licManufacturer') false 0 Manufacturer true 150 false false false ClasssettingsOutlayForCSLicenseSaleAndSwContracts This class setting is part of the config set "license sale and service contracts". <!-- =============== Outlay: ExpenseOutlayPage =============== --> <Page Override="ExpenseOutlay"> <!-- on regular outlays we only want to have regular outlay types, no licenses or servicecontract --> <ComboBox Override="Type" Label="{Translate 'Type'}" ValueExpression="type" ShowLabel="True" IsLabelBold="True" ListExpression="if ocliskindof(Expense) then self.oclAsType(Expense).expensetypesLookup else self.oclAsType(Outlay).outlaytypesLookup->select(zusatzfeldint('lic_kindOfOutlayType')=0) endif->orderby(asstring)"> <ComboBox.ColumnDefinitions> <ColumnDefinition Name="Code" Width="100" Expression="code" IsReadOnly="True" /> <ColumnDefinition Name="Text" Width="150" Expression="text" IsReadOnly="True" /> </ComboBox.ColumnDefinitions> </ComboBox> </Page> Outlay LnkAuslageAuslagetypphaselink Links an invoice with a license sale or servicecontract true true false false 0 true false OutlaytypePhaseLink 85 License sale and service contracts true true CurrentView false false 0 false false Outlay 48 Auslagen true true CurrentView 17 true true 0 1 cmbProject false project false 1 Project true 70 false false false 1 10 rndCascCurrency true feeext false 0 Total sales true 80 false false false 0 11 false text false 0 Text true 429 false false true project.language 0 2 cmbPhase false phase false 0 Phase true 70 false false false 0 3 false entryDate false 0 Date false 60 false false false 0 4 cmbExpenditureUser false user false 0 User false 65 false false false 0 5 cmbExpenditureTypes false type false 0 Type true 56 false false false 1 6 false quantity false 0 Quantity true 60 false false false 1 7 false feePerUnitInt false 0 Purchase price true 80 false false false 1 8 true feePerUnitExt false 0 Selling price true 80 false false false 1 9 false feeint false 0 Total purchases true 80 false false false ExpressionfolderLicenseProducts Licensed products 85 20 false true CurrentView 17 true true 0 1 false zusatzfeld('cc26_licProductname') false 1 Name true 150 false false false 0 2 false zusatzfeld('cc26_licManufacturer') false 0 Manufacturer true 150 false false false ConfigSetCustomClass26 ConfigSetCustomClass26.allinstances FolderPurchases Fremdkosten 5 270 false true CurrentView true false false true false FolderInvoiceslicenseSaleAndServiceContracts License sale and service contracts -1 950 false true CurrentView true false false true false 0 FolderInvoicing Invoicing_cs 9 40 false true CurrentView true false false true false 0 FolderSales Verkauf 88 20 false true CurrentView true false false true false 0 FolderSalesLicenseSaleAndServiceContracts License sale and service contracts -1 900 false true CurrentView true false false true false 0 Script_CalculatePriceFromLicenseSale calculate_price_from_licenses false # coding: windows-1252 # # Designation: calculate_price_from_licenses # Classes: # CondExpression: # ObjectScript: # ContainerScript: # EventType: # EventClass: # EventMembers: # Calculates the price of the service contract dependig on license sales # 2024-09-03, MKL: adjusting script according to PEP-8 import module_licenses module_licenses.calculate_price_from_licenses(argobject) None false false false Python2 Script_DeleteLicenseInvoice Event: Delete license invoice Invoice false # coding: windows-1252 # # Designation: Delete license invoice # Classes: # CondExpression: # ObjectScript: # ContainerScript: # EventType: Löschen # EventClass: Rechnung # EventMembers: # Deletes automatically created purchases on the invoice. # Otherwise, when deleting license invoices, # the purchases would remain in Vertec as open purchases # 2024-09-03, MKL: adjusting script according to PEP-8 import module_licenses module_licenses.delete_license_invoice(argobject) Delete false true false Python2 Script_moduleLicenses module_licenses false # coding: windows-1252 # # Designation: module_licenses # Classes: - # CondExpression: - # ObjectScript: - # ContainerScript: - # EventType: Kein # EventClass: - # EventMembers: - # ExtendedRights: N # Show in Menu: Y # Contains functions for license sales and service contracts # 2021-06-03, UHE: initial version # 2023-09-28, WCA: changed handling of VAT types # 2024-06-06, WCA: adjusted usage of the systemcontext instruction # to the more secure approach # 2024-07-02, WCA: Rearranged the approach used for disableevents # 2024-09-03, MKL: adjusting script according to PEP-8 # 2025-02-27, AVE: Rework event member for Vertec 6.8 # 2026-07-07, AVE: Rework configset, translations to EN import vtcapp import calendar from datetime import datetime # Constants LICENSE_KIND = 1 SERVICE_CONTRACT_KIND = 2 def charge_licenses(outlay_type_phase_link_list): """ Creates invoices for a list of 'licenses' Already invoiced licenses are ignored """ # Remove all items in list, that are not licenses outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl( "self->select(hastag('license'))") # Only take outlay_type_phase_links that were already sold (start date set) outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl( "self->reject(zusatzfelddate('lic_startdate').isNull)") # Only take outlay_type_phase_links without purchases (-> not charged already) outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl( "self->reject(getlinks('LnkAuslageAuslagetypphaselink_B')->size>0)") count_invoices = 0 if outlay_type_phase_link_list: # create purchases per project for project in outlay_type_phase_link_list.evalocl("phase.phaseGetProjekt->asSet"): license_purchases = [] for outlay_type_phase_link in outlay_type_phase_link_list: if outlay_type_phase_link.evalocl("phase.phaseGetProjekt") == project: purchase = vtcapp.createobject('OpenOutlay') # set tag on outlay purchase.addtag("license") purchase.project = outlay_type_phase_link.phase.evalocl('phaseGetProjekt') purchase.phase = outlay_type_phase_link.phase purchase.user = vtcapp.currentlogin() purchase.linkto(outlay_type_phase_link, "LnkAuslageAuslagetypphaselink_A") purchase.type = outlay_type_phase_link.outlaytype purchase.quantity = outlay_type_phase_link.lic_amount purchase.feePerUnitInt = outlay_type_phase_link.feePerUnitInt purchase.feePerUnitExt = outlay_type_phase_link.feePerUnitExt purchase.supplier = outlay_type_phase_link.lic_supplier # if there is a manufacturer defined, we add this to the # outlaytext and therefore also on the invoice manufacturer = outlay_type_phase_link.evalocl( "outlaytype.zusatzfeldobj('lic_product')"\ +"->oclAsType(ConfigSetCustomClass26)"\ +".zusatzfeldasstring('cc26_licManufacturer')") manufacturer_text = "" if manufacturer: manufacturer_text = " ({}: {})".format(vtcapp.translate("Manufacturer"), manufacturer) purchase.text = outlay_type_phase_link.evalocl( "if offerText='' then designation else "\ +"offerText endif + ' ' + '{}'".format(manufacturer_text)) if outlay_type_phase_link.lic_discountPercentage: purchase.discountPercent = outlay_type_phase_link.lic_discountPercentage else: if outlay_type_phase_link.lic_amount: purchase.xDiscountAmount = outlay_type_phase_link.lic_discount* \ outlay_type_phase_link.lic_amount else: purchase.xDiscountAmount = outlay_type_phase_link.lic_discount purchase.entryDate = outlay_type_phase_link.lic_startdate # Add purchase to list of purchases that will be invoiced # for the project license_purchases.append(purchase) # Create invoices if license_purchases: # create invoice invoice = vtcapp.createobject('Invoice') count_invoices += 1 invoice.startDate = None invoice.endDate = None invoice.project = project # remove all objects from invoice remove_objects_from_invoice(invoice) # add all purchases for purchase in license_purchases: purchase.invoice = invoice if count_invoices == 0: vtcapp.msgbox(vtcapp.translate("No licenses available for invoicing.")) elif count_invoices == 1: vtcapp.showdetailform(invoice) else: vtcapp.msgbox(vtcapp.translate("The process was successfully completed." + " {} invoices were created.").format(count_invoices)) else: vtcapp.msgbox(vtcapp.translate("No licenses available for invoicing.")) def charge_service_contracts(outlay_type_phase_link_list, is_special_invoice = False): """ Creates invoices for a list of service contracts. - Already invoiced service contracts are ignored - With is_special_invoice= True one (1) selected service contract invoice can be created which does not change the next invoicing date on the service contract """ init_values = {} # Remove (and remember) service contracts that must not be handled here ignored_otpl = [] for otpl in list(outlay_type_phase_link_list): # Remove service contracts that are not sold (no start_date set) # or where there is no next invoicing date or where the user # can not create invoices if (not otpl.lic_startdate) or (not otpl.lic_nextInvoicingDate)\ or (not otpl.phase.project.checkright("Create", "invoice")): # remove from main list outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl("self->reject(objid={})".format(otpl.objid)) # remember what we removed ignored_otpl.append(otpl) # Remove service contract where the cancellation_to date # is before the next invoicing date if otpl.lic_endDate and otpl.lic_nextInvoicingDate and (otpl.lic_nextInvoicingDate > otpl.lic_endDate): # remove from main list outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl("self->reject(objid={})".format(otpl.objid)) # remember what we removed ignored_otpl.append(otpl) dlg_content = "" # List service contracts that will be processed if outlay_type_phase_link_list: if not is_special_invoice: count_invoices = 0 dlg_content += """ <ScrollableGroup Orientation="Vertical" ShowVerticalScrollbar="True" MaxGroupHeight="200"> <Table FillLastColumn="True"> <Table.Columns> <TableColumn Width="80"> <TextBlock Text="{Translate 'Project'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="165"> <TextBlock Text="{Translate 'Designation'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="5"> <TextBlock Text="" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="150"> <TextBlock Text="{Translate 'Period'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn> <TextBlock Text="{Translate 'Date of last invoice'}" IsBold="True" Appearance="ColumnHeader"/> </TableColumn> </Table.Columns> """ # Sort by project outlay_type_phase_link_list = outlay_type_phase_link_list.evalocl("self->orderby(phase.owningproject.code)") last_project = "" for otpl in outlay_type_phase_link_list: project = otpl.phase.owningproject period_start, period_end = calculate_invoicing_period(otpl) last_invoice_date = otpl.evalocl("self->getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Outlay)" "->select(type.zusatzfeldint('lic_kindOfOutlayType')>0).invoice" "->orderby(entrydate).entrydate->last") dlg_content += """ <TableRow> <TableCell> <TextBlock Appearance="Info" Text="{}" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{}" Help="{}" /> </TableCell> <TableCell> <TextBlock Text="" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{} - {}" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{}" /> </TableCell> </TableRow> """.format(htmlescape(project) if project != last_project else "", htmlescape(otpl.designation), htmlescape(otpl.designation), vtcapp.datetostr(period_start), vtcapp.datetostr(period_end), vtcapp.datetostr(last_invoice_date) if last_invoice_date else "-") count_invoices += 1 if project != last_project else 0 last_project = project # add closing tags dlg_content += """ </Table> </ScrollableGroup> <Spacer /> <Group Orientation="Vertical" HorizontalAlignment="Left" LabelWidth="160"> <TextBlock Label="{{Translate 'Invoices to be generated'}}" ShowLabel="True" Text="{}" /> <DatePicker Name="InvoiceDate" Label="{{Translate 'Invoice date'}}" HorizontalAlignment="Left"/> </Group> <Spacer /> """.format(count_invoices) elif is_special_invoice and (len(outlay_type_phase_link_list) == 1): # Here we process a special invoice. Show already invoiced items otpl = outlay_type_phase_link_list[0] dlg_content += """ <TextBlock Label="{{Translate 'Designation'}}" ShowLabel="True" Text="{}" IsBold="True"/> <TextBlock Label="{{Translate 'Start date'}}" ShowLabel="True" Text="{}" /> <TextBlock Label="{{Translate 'Invoice period'}}" ShowLabel="True" Text="{}" /> <TextBlock Label="{{Translate 'Charge type'}}" ShowLabel="True" Text="{}" /> <Spacer /> <TextBlock Appearance="Info" Text="{{Translate 'Charged'}}" IsBold="True" /> <ScrollableGroup ShowVerticalScrollbar="True" MaxGroupHeight="200"> <Table FillLastColumn="True"> <Table.Columns> <TableColumn Width="80"> <TextBlock Text="{{Translate 'Date'}}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="350"> <TextBlock Text="{{Translate 'Text'}}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn> <TextBlock Text="{{Translate 'Net amount'}}" IsBold="True" Appearance="ColumnHeader" HorizontalAlignment="Right" /> </TableColumn> </Table.Columns> """.format(htmlescape(otpl.designation), vtcapp.datetostr(otpl.lic_startDate), otpl.evalocl("zusatzfeldasstring('lic_accountingInterval')"), otpl.evalocl("zusatzfeldasstring('lic_charge_type')")) # Get all outlays of the service contract otpl_outlays = otpl.evalocl( "getlinks('LnkAuslageAuslagetypphaselink_B')" "->oclastype(Outlay)->orderby(entrydate)") for ol in otpl_outlays: dlg_content += """ <TableRow> <TableCell> <TextBlock Appearance="Info" Text="{}" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{}" Help="{}" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{}" HorizontalAlignment="Right"/> </TableCell> </TableRow> """.format(vtcapp.datetostr(ol.entrydate), htmlescape(ol.text), htmlescape(ol.text), htmlescape(ol.feeExt)) # add closing tags dlg_content += """ </Table> </ScrollableGroup> <Spacer Height="7" /> <Group Orientation="Vertical" HorizontalAlignment="Left" > <DatePicker Name="InvoiceDate" Label="{Translate 'Invoice date'}" /> <DatePicker Name="PeriodStart" Label="{Translate 'Period start'}" /> </Group> <Spacer /> """ init_values['PeriodStart'] = otpl.lic_startDate else: # This case (Script for special invoice executed on a list) should not happen with the # Script expression, but even this error case is covered here vtcapp.msgbox("A special invoice can only be created on one service contract, not on a list") return # List service contracts that will be ignored if ignored_otpl: dlg_content += """ <Spacer Height="20"/> <TextBlock Appearance="Info" IsBold="True" Text="{Translate 'Not considered'}" /> <ScrollableGroup ShowVerticalScrollbar="True" MaxGroupHeight="200"> <Table FillLastColumn="True"> <Table.Columns> <TableColumn Width="80"> <TextBlock Text="{Translate 'Project'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="165"> <TextBlock Text="{Translate 'Designation'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="5"> <TextBlock Text="" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="90"> <TextBlock Text="{Translate 'Start date'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn Width="90"> <TextBlock Text="{Translate 'End date'}" IsBold="True" Appearance="ColumnHeader" /> </TableColumn> <TableColumn> <TextBlock Text="{Translate 'Next invoicing'}" IsBold="True" Appearance="ColumnHeader"/> </TableColumn> </Table.Columns> """ for otpl in ignored_otpl: dlg_content += """ <TableRow> <TableCell> <TextBlock Appearance="Info" Text="{}" /> </TableCell> <TableCell> <TextBlock Appearance="Info" Text="{}" Help="{}" /> </TableCell> <TableCell> <TextBlock Text="" /> </TableCell> <TableCell> <TextBlock Text="{}" /> </TableCell> <TableCell> <TextBlock Text="{}" /> </TableCell> <TableCell> <TextBlock Text="{}" /> </TableCell> </TableRow> """.format(htmlescape(otpl.phase.evalocl("phasegetproject")), htmlescape(otpl.designation), htmlescape(otpl.designation), vtcapp.datetostr(otpl.lic_startdate) if otpl.lic_startdate else "-", vtcapp.datetostr(otpl.lic_endDate) if otpl.lic_endDate else "-", vtcapp.datetostr(otpl.lic_nextInvoicingDate) if otpl.lic_nextInvoicingDate else "-") # add closing tag dlg_content += """ </Table> </ScrollableGroup> """ # Show detail dialog dlg_header = """ <Dialog Title="{Translate 'Charge service contracts'}" Width="600" > """ dlg_footer = """ <Dialog.Buttons> <Button Name="okbutton" Text="OK" IsAccept="True" Command="{Binding OkCommand}" /> <Button Text="{Translate 'Cancel'}" IsCancel="True" Command="{Binding CancelCommand}" /> </Dialog.Buttons> </Dialog> """ # Show dialog dlg_definition = "{}{}{}".format(dlg_header, dlg_content, dlg_footer) init_values['InvoiceDate'] = datetime.today() if not outlay_type_phase_link_list: init_values['okbutton.Visible'] = False ok, values = vtcapp.showcustomdialog(dlg_definition, init_values) if not ok: # Dialog cancelled by user return else: # Create the invoices count_invoices = 0 invoice_date = values['InvoiceDate'] # Create purchases per project for project in outlay_type_phase_link_list.evalocl("phase.phaseGetProjekt->asSet"): purchase_list = [] # Per project we create only one invoice. For that we need the # invoicing period, which will be calculated in the following, # but initialized here invoicing_period_start = None invoicing_period_end = None for outlay_type_phase_link in outlay_type_phase_link_list: if outlay_type_phase_link.evalocl("phase.phaseGetProjekt") == project: # Get the invoicing period if not is_special_invoice: # Regular invoice period_start, period_end = calculate_invoicing_period(outlay_type_phase_link) else: # Is a special invoice, start date and period start given by user period_start = values['PeriodStart'] period_end = vtcapp.incday(increment_date_by_accounting_interval( period_start, outlay_type_phase_link.lic_accountingInterval), -1) # Create the outlay purchase = vtcapp.createobject("OpenOutlay") purchase.phase = outlay_type_phase_link.phase purchase.type = outlay_type_phase_link.outlaytype vat_periods_list = calculate_vat_periods(period_start, period_end, purchase.vatType) for vat_period in vat_periods_list: if not purchase: # Create new purchase purchase = vtcapp.createobject("OpenOutlay") # Add information from service contract purchase.addtag("servicecontract") purchase.user = vtcapp.currentlogin() purchase.type = outlay_type_phase_link.outlaytype purchase.phase = outlay_type_phase_link.phase purchase.linkto(outlay_type_phase_link, "LnkAuslageAuslagetypphaselink_A") purchase.entryDate = vat_period.period_start purchase.margin = None purchase.supplier = outlay_type_phase_link.lic_supplier purchase.feePerUnitExt = outlay_type_phase_link.feePerUnitExt purchase.feePerUnitInt = outlay_type_phase_link.feePerUnitInt if outlay_type_phase_link.lic_amount: purchase.quantity = outlay_type_phase_link.lic_amount * \ vat_period.partial_vat_factor else: purchase.xFeeExt = outlay_type_phase_link.planFeeOutlaysExt * \ vat_period.partial_vat_factor if outlay_type_phase_link.lic_discountPercentage: purchase.discountPercent = outlay_type_phase_link.lic_discountPercentage elif outlay_type_phase_link.lic_discount: if outlay_type_phase_link.lic_amount: purchase.xDiscountAmount = outlay_type_phase_link.lic_discount \ * outlay_type_phase_link.lic_amount \ * vat_period.partial_vat_factor else: purchase.xDiscountAmount = outlay_type_phase_link.lic_discount \ * vat_period.partial_vat_factor else: purchase.xDiscountAmount = 0 purchase.text = outlay_type_phase_link.evalocl( "if offerText='' then designation else offerText endif ") period_text = generate_period_text(vat_period.period_start, vat_period.period_end_date, project.evalocl("language.asString")) # if we have a pro rata purchase because of # partial vat period we want to change # the period text if vat_period.partial_vat_factor != 1: purchase.text += " (Pro rata {})".format( period_text) else: # No VAT change in period # (vat_period.partial_vat_factor == 1) purchase.text += " ({})".format(period_text) purchase.setkeyvalue("periodText", period_text) purchase_list.append(purchase) purchase = None # For the invoice we need the invoicing period, we # take it from the periods of the different # service contracts. We use the earliest date for # start and the latest date for end if not invoicing_period_start: invoicing_period_start = period_start else: if period_start < invoicing_period_start: invoicing_period_start = period_start if not invoicing_period_end: invoicing_period_end = period_end else: if period_end > invoicing_period_end: invoicing_period_end = period_end # Now we set the next invoicing date on the # outlay_type_phase_link and save before the last date as key # (if it's not a special invoice) if not is_special_invoice: # Save the current invoicing date as key: actual_next_invoicing_date = outlay_type_phase_link.lic_nextInvoicingDate outlay_type_phase_link.setkeyvalue("previous_last_invoicing_date", actual_next_invoicing_date) # Set the next invoicing date set_next_invoicing_date(outlay_type_phase_link, actual_next_invoicing_date) # End of loop through the outlay_type_phase_links if purchase_list: # Create one invoice for all purchases of the project invoice = vtcapp.createobject("Invoice") invoice.project = project invoice.startDate = invoicing_period_start invoice.endDate = invoicing_period_end invoice.entryDate = invoice_date remove_objects_from_invoice(invoice) # add the created purchases to the invoice for purchase in purchase_list: purchase.invoice = invoice # Invoice is created, increment counter count_invoices += 1 # End loop for projects if count_invoices == 1: vtcapp.showdetailform(invoice) if is_special_invoice: # In case of special invoice, show created outlay(s) for outlay in invoice.outlays: vtcapp.showdetailform(outlay) else: vtcapp.msgbox(vtcapp.translate("The process was successfully completed. " +"{} invoices were created.").format(count_invoices)) return def increment_date_by_accounting_interval(date, accounting_interval, inc=True): """ Used to calculate a (next billing) date, based on the accounting_interval: 0:Monthly -> date + 1 month 1:Quarterly -> date + 3 months 2:Semi-Annually -> date + 6 months 3:Yearly -> date + 1 year For all other values, the unchanged value will be returned The date can be decremented accordingly using the optional parameter `inc = False` """ if accounting_interval == 0: # increment one month new_date = vtcapp.incmonth(date, 1 if inc else -1) elif accounting_interval == 1: # increment 1 quarter (3 months) new_date = vtcapp.incmonth(date, 3 if inc else -3) elif accounting_interval == 2: # increment 1/2 year new_date = vtcapp.incmonth(date, 6 if inc else -6) elif accounting_interval == 3: # increment 1 year new_date = vtcapp.incyear(date, 1 if inc else -1) else: # ... return unchanged date new_date = date return new_date def remove_objects_from_invoice(invoice): """ Removes all entries from the invoice. This must be done after the period has been set. If you change the period on an invoice, related entries will be added """ for obj in list(invoice.evalocl("services")): obj.invoice = None for obj in list(invoice.evalocl("expenses")): obj.invoice = None for obj in list(invoice.evalocl("outlays")): obj.invoice = None for obj in list(invoice.evalocl("phasesFixedPrice")): obj.invoice = None for obj in list(invoice.evalocl("downpaymentsToCharge")): obj.chargedInvoice = None for obj in list(invoice.evalocl("downpaymentsToDeduct")): obj.deductedInvoices.remove(invoice) def number_format(value): """ Formats a number to be used in a dialog (using jinja renderer) """ return vtcapp.formatnumber(value) def outlaytype_changes_on_outlay_type_phase_link(outlay_type_phase_link): """ we only want to set values for licenses and service contracts """ outlay_type = outlay_type_phase_link.outlaytype if not outlay_type: return if not (outlay_type.lic_kindOfOutlayType == LICENSE_KIND or outlay_type.lic_kindOfOutlayType == SERVICE_CONTRACT_KIND): return # Reset this checkbox, it must only be used on service contracts. # To avoid issues, we set it to False outlay_type_phase_link.lic_calcPrice = False # we add tags to easily identify the object as license sales or # service contract if outlay_type.lic_kindOfOutlayType == LICENSE_KIND: outlay_type_phase_link.addtag("license") else: outlay_type_phase_link.removetag("license") if outlay_type.lic_kindOfOutlayType == SERVICE_CONTRACT_KIND: outlay_type_phase_link.addtag("servicecontract") else: outlay_type_phase_link.removetag("servicecontract") outlay_type_phase_link.designation = outlay_type.text outlay_type_phase_link.offertext = outlay_type.text outlay_type_phase_link.feePerUnitInt = outlay_type.feePerUnitInt outlay_type_phase_link.costPerUnit = outlay_type.costPerUnit outlay_type_phase_link.feePerUnitExt = outlay_type.feePerUnitExt outlay_type_phase_link.lic_supplier = outlay_type.lic_supplier outlay_type_phase_link.lic_noticePeriod = outlay_type.lic_noticePeriod if outlay_type.lic_kindOfOutlayType == SERVICE_CONTRACT_KIND: # Is a service contract outlay_type_phase_link.lic_accountingInterval = outlay_type.lic_accountingInterval outlay_type_phase_link.lic_charge_type = outlay_type.lic_charge_type def value_changes_on_outlay_type_phase_link(outlay_type_phase_link, eventmember): """ Various members on the outlay_type_phase_link have dependencies. So we have to recalculate them if changes happen """ if not outlay_type_phase_link: return phase = outlay_type_phase_link.phase if not phase: return project = phase.owningProject if not project: return # we only want to calculate rates for licenses and service contracts outlay_type = outlay_type_phase_link.outlaytype if not outlay_type: return if not (outlay_type.lic_kindOfOutlayType == LICENSE_KIND or outlay_type.lic_kindOfOutlayType == SERVICE_CONTRACT_KIND): return if not outlay_type_phase_link.lic_discount: # We always want to remove discount without check, therefore # it is set to zero when None outlay_type_phase_link.lic_discount = 0 if eventmember.lower() in ("planFeeOutlaysExt".lower(), "planWertAuslagen".lower()): # if total is set manually, remove discount, amount and unit values outlay_type_phase_link.lic_discountPercentage = None outlay_type_phase_link.lic_discount = 0 outlay_type_phase_link.feePerUnitExt = None outlay_type_phase_link.lic_amount = None outlay_type_phase_link.lic_calcPrice = False outlay_type_phase_link.setkeyvalue("lic_textlicenses", "") return if eventmember.lower() in ("feePerUnitExt".lower(), "wertProEinheitExt".lower()): # if unit value is set, calculate discount and total if outlay_type_phase_link.feePerUnitExt: if outlay_type_phase_link.lic_discountPercentage: outlay_type_phase_link.lic_discount = outlay_type_phase_link.feePerUnitExt * \ outlay_type_phase_link.lic_discountPercentage/100 if outlay_type_phase_link.lic_amount: outlay_type_phase_link.planFeeOutlaysExt = outlay_type_phase_link.lic_amount * \ (outlay_type_phase_link.feePerUnitExt - \ outlay_type_phase_link.lic_discount) else: outlay_type_phase_link.planFeeOutlaysExt = 0 return if eventmember == "lic_discountPercentage": # if discount percentage (additional field) is set, calculate discount and total if outlay_type_phase_link.lic_discountPercentage \ and outlay_type_phase_link.feePerUnitExt: outlay_type_phase_link.lic_discount = outlay_type_phase_link.feePerUnitExt * \ outlay_type_phase_link.lic_discountPercentage / 100 if outlay_type_phase_link.lic_amount: outlay_type_phase_link.planFeeOutlaysExt = outlay_type_phase_link.lic_amount * \ (outlay_type_phase_link.feePerUnitExt - \ outlay_type_phase_link.lic_discount) else: outlay_type_phase_link.lic_discount = 0 if outlay_type_phase_link.lic_amount and outlay_type_phase_link.feePerUnitExt: outlay_type_phase_link.planFeeOutlaysExt = outlay_type_phase_link.lic_amount * \ outlay_type_phase_link.feePerUnitExt return if eventmember == "lic_endDate": # If next invoicing date is after the end date next invoicing date # will be removed if outlay_type_phase_link.lic_nextInvoicingDate and (outlay_type_phase_link.lic_endDate < outlay_type_phase_link.lic_nextInvoicingDate): outlay_type_phase_link.lic_nextInvoicingDate = None return if eventmember == "lic_amount": # if amount is set (additional field), calculate discount and total if outlay_type_phase_link.lic_amount and outlay_type_phase_link.feePerUnitExt: if outlay_type_phase_link.lic_discountPercentage: outlay_type_phase_link.lic_discount = outlay_type_phase_link.feePerUnitExt * \ outlay_type_phase_link.lic_discountPercentage/100 if outlay_type_phase_link.feePerUnitExt: outlay_type_phase_link.planFeeOutlaysExt = outlay_type_phase_link.lic_amount * \ (outlay_type_phase_link.feePerUnitExt - \ outlay_type_phase_link.lic_discount) else: outlay_type_phase_link.planFeeOutlaysExt = 0 return if eventmember == "lic_discount": # if discount is set (additional field), remove discount percentage # and calculate total outlay_type_phase_link.lic_discountPercentage = None if outlay_type_phase_link.lic_amount and outlay_type_phase_link.feePerUnitExt: outlay_type_phase_link.planFeeOutlaysExt = outlay_type_phase_link.lic_amount * \ (outlay_type_phase_link.feePerUnitExt - \ outlay_type_phase_link.lic_discount) return if eventmember == "lic_calcPrice": # activated (additional field), set all previous calculations to zero if outlay_type_phase_link.lic_calcPrice: # Checkbox set outlay_type_phase_link.lic_discountPercentage = None outlay_type_phase_link.lic_discount = 0 outlay_type_phase_link.feePerUnitExt = None outlay_type_phase_link.lic_amount = None outlay_type_phase_link.planFeeOutlaysExt = 0 else: # Checkbox removed # Remove the amount outlay_type_phase_link.lic_amount = None outlay_type_phase_link.feePerUnitExt = outlay_type.feePerUnitExt outlay_type_phase_link.setkeyvalue("licpercent", None) outlay_type_phase_link.setkeyvalue("lictotal", None) outlay_type_phase_link.setkeyvalue("lic_textlicenses", None) outlay_type_phase_link.planFeeOutlaysExt = 0 # Note: The following members are only changeable as long as no invoice has # been created. This is ensured on the page settings (customizing) of Vertec if eventmember in ("lic_startDate", "lic_charge_type", "lic_accountingInterval"): # is a start date value set? If not, reset next invoicing date if outlay_type_phase_link.lic_startDate: set_next_invoicing_date(outlay_type_phase_link, outlay_type_phase_link.lic_startDate) else: # date value not set or deleted. Remove next invoicing date outlay_type_phase_link.lic_nextInvoicingDate = None return def new_outlay_type_phase_link(phase, kind): """ Creates a new purchase type phase link for license sale or service contract on a phase. kind = 1: license sale, kind = 2: service contract """ if not phase: return elif kind == 1: # New license sales outlay_type_phase_link = vtcapp.createobject("OutlaytypePhaseLink") # Important: phase must be set first, because the corresponding # user rights are needed to write outlay_type_phase_link.phase = phase outlay_type_phase_link.addtag("license") elif kind == 2: # New service contract outlay_type_phase_link = vtcapp.createobject("OutlaytypePhaseLink") # Important: phase must be set first, because the corresponding # user rights are needed to write outlay_type_phase_link.phase = phase outlay_type_phase_link.addtag("servicecontract") else: # kind <> 1 or 2 return # Start with default values. # Some values should not trigger the related event, # not all needed members are set yet with vtcapp.DisabledEvents(): # set accounting interval to annual outlay_type_phase_link.lic_accountingInterval = 3 # Set Charge type interval to "in advance" outlay_type_phase_link.lic_charge_type = 0 vtcapp.showdetailform(outlay_type_phase_link) return def calculate_price_from_licenses(obj): """ Function with dialog to calculate the service contract price based on a license """ dialog = """ <Dialog Title="{Translate 'Select licences' }" Width="750"> <TextBlock Text="{Translate 'Please select the licences from which the price is to be calculated.' }" Appearance="Info" FitMode="Wrap"/> <TextBlock ShowLabel="True" IsBold="True" Label="{Translate 'Project' }" Text="{{project| e}}" Appearance="Info"/> <TextBlock ShowLabel="True" IsBold="True" Label="{Translate 'Product' }" Text="{{product| e}}" Appearance="Info"/> <Spacer Height="10"/> <Group> <TextBlock IsBold="True" Text="{Translate 'Licence sale'}" Appearance="Info" HorizontalAlignment="Left" FlexWidth="6"/> <TextBlock IsBold="True" Text="{Translate 'Purchase date'}" Appearance="Info" HorizontalAlignment="Left" FlexWidth="2"/> <TextBlock IsBold="True" Text="{Translate 'Quantity'}" Appearance="Info" HorizontalAlignment="Right"/> {% if is_incl_discount %} <TextBlock IsBold="True" Text="{Translate 'Price incl. discount'}" Appearance="Info" HorizontalAlignment="Right" FlexWidth="2"/> {% else %} <TextBlock IsBold="True" Text="{Translate 'Price'}" Appearance="Info" HorizontalAlignment="Right"/> {% endif %} <TextBlock IsBold="True" Text="{Translate 'Total'}" Appearance="Info" HorizontalAlignment="Right" FlexWidth="2"/> </Group> {% for license in licenses %} <Group> <CheckBox Name="{{"Check"+license.evalocl("objid.asstring")}}" FlexWidth="6" Text="{{license.evalocl("if offerText='' then designation else offerText endif")| e}}" ShowLabel="False" HorizontalAlignment="Left"/> <TextBlock Text="{{license.evalocl("zusatzfeldasstring('lic_startdate')")}}" Appearance="Info" HorizontalAlignment="Left" FlexWidth="2"/> <TextBlock Text="{{license.evalocl("zusatzfeldasstring('lic_amount')")}}" Appearance="Info" HorizontalAlignment="Right"/> {% if is_incl_discount %} <TextBlock Text="{{number_format(license.evalocl("feePerUnitExt - zusatzfeldcurr('lic_discount')"))}}" Appearance="Info" FlexWidth="2" HorizontalAlignment="Right"/> {% else %} <TextBlock Text="{{license.evalocl("feePerUnitExt.asString")}}" Appearance="Info" HorizontalAlignment="Right"/> {% endif %} {% if is_incl_discount %} <TextBlock Text="{{license.evalocl("planFeeOutlaysExt.asString")}}" Appearance="Info" HorizontalAlignment="Right" FlexWidth="2"/> {% else %} <TextBlock Text="{{number_format(license.evalocl("if feePerUnitExt.notNull then feePerUnitExt * zusatzfeldcurr('lic_amount') else planFeeOutlaysExt endif"))}}" Appearance="Info" HorizontalAlignment="Right" FlexWidth="2"/> {% endif %} </Group> {% endfor %} <Spacer Height="10"/> <TextBlock Text="{Translate 'Please enter the percentage of the licence amount (sum of the selected entries) to be charged in the service contract.' }" Appearance="Info" FitMode="Wrap"/> <TextBox Name="Percentage" IsLabelBold="True" ContentAlignment="Right" Label="{Translate 'Percent'}" WidthFraction="0.3"/> <Dialog.Buttons> <Button Text="OK" IsAccept="True" Command="{Binding OkCommand}" /> <Button Text="{Translate 'Cancel'}" IsCancel="True" Command="{Binding CancelCommand}" /> </Dialog.Buttons> </Dialog> """ service_contract = obj project = service_contract.evalocl("phase.phaseGetProjekt") product = service_contract.evalocl("outlaytype.zusatzfeldobj('lic_product')") if not product: license_list = service_contract.evalocl( "phase.phaseGetProjekt.allPhases.outlaytypeLinks->select(hastag('license'))") product_name = "" else: license_list = service_contract.evalocl( "phase.phaseGetProjekt.allPhases.outlaytypeLinks\ ->select(outlaytype.zusatzfeldobj('lic_product').objid={})\ ->select(hastag('license'))"\ .format(str(product.objid))) product_name = product.cc26_licProductname if not license_list: vtcapp.msgbox(vtcapp.translate("There are no license sales for this product.")) return is_incl_discount = service_contract.outlaytype.lic_calcInclDiscount dialog = vtcapp.rendertemplate(dialog, vtcapp=vtcapp, project=project.code, product=product_name, licenses=license_list, is_incl_discount=is_incl_discount, number_format=number_format) init_values = {} init_values["Percentage"] = service_contract.evalocl( "outlaytype.zusatzfeldcurr('lic_percentageOfSoldLicenses').asstring") for license in license_list: init_values["Check"+license.evalocl("objid.asstring")] = True ok, values = vtcapp.showcustomdialog(dialog, init_values) if not ok: return total = 0 for license in license_list: if values["Check"+license.evalocl("objid.asstring")]: if (service_contract.outlaytype.lic_calcInclDiscount or not (license.lic_amount and license.feePerUnitExt)): total += license.planFeeOutlaysExt else: total += license.lic_amount * license.feePerUnitExt try: percent = float(values["Percentage"].replace(",", "."))/100.0 except (ValueError, AttributeError): vtcapp.msgbox(vtcapp.translate("Invalid percentage")) return calculated_text = "{} {} {} = {}".format(vtcapp.formatnumber(percent*100), vtcapp.translate("% of license total"), vtcapp.formatnumber(total), vtcapp.formatnumber(total*percent)) # we disable events because setting values would trigger all # associated scripts for the following items with vtcapp.DisabledEvents(): service_contract.planFeeOutlaysExt = total*percent service_contract.feePerUnitExt = total*percent service_contract.setkeyvalue("lic_textlicenses", calculated_text) service_contract.setkeyvalue("licpercent", percent) service_contract.setkeyvalue("lictotal", total) # We set the amount of service contracts to 1 service_contract.lic_discount = None service_contract.lic_discountPercentage = None service_contract.lic_amount = 1 def calculate_invoicing_period(outlay_type_phase_link): """ Returns the start- and end date for the invoicing period It takes into account the charging type and the invoicing interval """ if outlay_type_phase_link.lic_charge_type == 0: # Charge type "In Advance", so the (first) invoicing date # is the start_date # Calculate the start date depending on the invoice interval. period_start_date = outlay_type_phase_link.lic_nextInvoicingDate # Increment period length from (start_date -1 day), # create period end date accounting_interval = outlay_type_phase_link.lic_accountingInterval interim_date = increment_date_by_accounting_interval(period_start_date, accounting_interval, inc=True) # Special case: Start date is at end of month. So we assume the next # invoicing date period ends one day before the next invoicing date, which must # always be at end of month and not on the same day number of month if is_start_date_last_of_month(outlay_type_phase_link): interim_date = vtcapp.lastdayofmonth(interim_date) period_end_date = vtcapp.incday(interim_date, -1) else: # Charge type "In arrears", so the period end is equal to the next # invoicing date period_end_date = outlay_type_phase_link.lic_nextInvoicingDate # Calculate the start date depending on the invoice interval. # Subtract period length from end_date then add 1 day accounting_interval = outlay_type_phase_link.lic_accountingInterval period_start_date = increment_date_by_accounting_interval(period_end_date, accounting_interval, inc=False) # Special case 1: Start date is at the beginning of the month. # Then the calculated period start should always be beginning of month if is_start_date_first_of_month(outlay_type_phase_link): # Increment days so we are guaranteed in the next month # (ex. 30.10. -> 4.11.) Then get the first day of month period_start_date = vtcapp.firstdayofmonth(vtcapp.incday(period_start_date, 5)) # Special case 2: Start date is end of the month. # Then check if the calculated period start is already end of month. # Then do not increment day. Period start in this special case should # always be end of month elif is_start_date_last_of_month(outlay_type_phase_link): period_start_date = vtcapp.lastdayofmonth(period_start_date) else: period_start_date = vtcapp.incday(period_start_date, 1) return period_start_date, period_end_date def delete_license_invoice(invoice): """ If invoice is deleted, delete all purchases that were created by script "Charge service contracts" or "Charge licenses" """ if invoice.outlays: outlay_list = invoice.evalocl("outlays->select(hastag('license')" "or hastag('servicecontract'))") if outlay_list: # outlay_list are outlays, get the outlay_type_phase_links # Note: On an invoice there may be more than one service contract outlay_type_phase_links = outlay_list.evalocl("self->" "getlinks('LnkAuslageAuslagetypphaselink_A')" "->asSet") for outlay_type_phase_link in outlay_type_phase_links: # Set the next invoicing date back on Service contracts # but only if this was the LAST invoice! if ((outlay_type_phase_link.outlaytype.lic_kindOfOutlayType == SERVICE_CONTRACT_KIND) and (invoice == outlay_type_phase_link.evalocl("self" "->getlinks('LnkLicenseSaleAndServiceContractsInvoices_A')" "->oclastype(Invoice)->orderby(creationdatetime)->last")) and outlay_type_phase_link.getkeydate('previous_last_invoicing_date')): # The last invoicing date is stored as key, restore date, delete key outlay_type_phase_link.lic_nextInvoicingDate = outlay_type_phase_link\ .getkeydate("previous_last_invoicing_date") outlay_type_phase_link.setkeyvalue("previous_last_invoicing_date", None) # Delete all assigned outlays (for licenses and service contracts) for ol in list(outlay_list): ol.delete() return def date_as_month_text(month_date, language): """ Returns the month of a date in a specific language """ if month_date: # Returns text in format "July 2021" return "{} {}".format(vtcapp.translate(calendar.month_name[month_date.month], language),month_date.year) else: return "" def date_as_date_text(month_date, language): """ Returns the full date in a specific language """ if month_date: # Returns text in format "12. July 2027" day = str(month_date.day) month_name = vtcapp.translate(calendar.month_name[month_date.month], language) year = str(month_date.year) return "{}. {} {}".format(day, month_name, year) else: return "" def generate_period_text(start_month, end_month, language): """ Calculates a text that returns the period in a specific language, e.g. "July 2021 - September 2021" """ return "{} - {}".format(date_as_date_text(start_month, language), date_as_date_text(end_month, language)) def get_months_diff(date1, date2): """ Calculates the difference in months between two dates and returns result as float """ return float(date2.year*12 + date2.month+1 - (date1.year*12 + date1.month)) class VATPeriod(): """ Class for VAT periods """ def __init__(self, period_start, period_end_date, partial_vat_factor): self.period_start = period_start self.partial_vat_factor = partial_vat_factor self.period_end_date = period_end_date def calculate_vat_periods(start_month, end_month, vat_type): """ Calculates vat periods in Vertec depending on vat changes (MWSTDetail in Vertec) First we search for all possible changes in the given interval """ possible_vat_changes_list = vat_type.evalocl("detailItems->select(rate.notNull)\ ->select(entryDate.notNull)\ ->select(entryDate>={})\ ->select(entryDate<={})\ ->orderby(entryDate)"\ .format(vtcapp.ocldate(start_month),\ vtcapp.ocldate(end_month))) # We start with the given start_month, but as we have to compare # to dates later on, we remove the time part of the datetime actual_start_date = start_month.date() vat_periods_list = [] # We create an object for the first entry or only entry # if no changes exist vat_period_obj = VATPeriod(start_month, end_month, 1) vat_periods_list.append(vat_period_obj) # The end of each period is defined by the start of the next one. # So we have to edit each previous object when we reach the next one. prev_obj = vat_period_obj for vat_change in possible_vat_changes_list: vat_change_date = vat_change.entryDate.date() # We only take into account periods with length > 0, # i.e., the start date of the new period must be > (not >=) # than the start date of the last period # If there is more than one object with same change date # one of them is ignored (randomly) if actual_start_date <= vat_change_date \ and vat_change_date > prev_obj.period_start.date(): # The end date for the previous period is one day # before the start date of the actual period last_end_date = vtcapp.incday(vat_change_date, -1) actual_start_date = vat_change_date vat_period_obj = VATPeriod(actual_start_date, None, None) vat_periods_list.append(vat_period_obj) prev_obj.period_end_date = last_end_date # For each object we calculate, which part the time # interval has in relation to the whole given period. # This gives us a factor that we can use to calculate # the amount that has to be charged for this part # of the period later prev_obj.partial_vat_factor = ((get_months_diff(prev_obj.period_start, last_end_date)) /(get_months_diff(start_month, end_month))) # When we step to the next period the actual object # becomes the new previous object prev_obj = vat_period_obj # The very last object in the list is now stored in prev_obj and we set the # end date of the period as end date also for the last part of the period # we have to calculate the part of the interval. # If there were no changes at all, period_start and period_end_date # are the same as start_month and end_month and the factor is 1 prev_obj.period_end_date = end_month prev_obj.partial_vat_factor = ((get_months_diff(prev_obj.period_start, end_month)) /(get_months_diff(start_month, end_month))) return vat_periods_list def get_amount_service_contracts(client, monthdate): """ Returns for a client the amount of invoiced service contracts in the given month. monthdate must be the first of the needed month """ result = 0 # Get all service contracts for a client outlay_type_phase_link_list = client.evalocl("projects.allPhases.outlaytypeLinks" +"->select(hastag('servicecontract'))") # We only need the contracts that are already invoiced (linked outlays) outlays = outlay_type_phase_link_list.evalocl("self->getLinks('LnkAuslageAuslagetypphaselink_B')") for outlay in outlays: # Is there an outlay in this month? if vtcapp.firstdayofmonth(outlay.entryDate) == monthdate: result += outlay.evalocl("feeExt * exchangeRate") return result def get_amount_licenses(client, monthdate): """ Returns for a client the amount of invoiced licenses in the given month. monthdate must be the first of the needed month """ result = 0 # Get all licenses for a client outlay_type_phase_link_list = client.evalocl("projects.allPhases.outlaytypeLinks" +"->select(hastag('license'))") # We only need the contracts that are already invoiced (linked outlays) outlays = outlay_type_phase_link_list.evalocl("self->getLinks('LnkAuslageAuslagetypphaselink_B')") for outlay in outlays: # Is there an outlay in this month? if vtcapp.firstdayofmonth(outlay.entryDate) == monthdate: result += outlay.evalocl("feeExt * exchangeRate") return result def set_next_invoicing_date(outlay_type_phase_link, date): """ Sets the next_invoicing date, based on the date - lic_charge_type -> 0:In advance, 1:In arrears - lic_accountingInterval ->0: monthly 1:Quarterly, 2:Semi-Annually, 3:Yearly """ start_date = outlay_type_phase_link.lic_startDate current_next_invoicing_date = outlay_type_phase_link.lic_nextInvoicingDate accounting_interval = outlay_type_phase_link.lic_accountingInterval if outlay_type_phase_link.lic_charge_type == 0: # Charge type "In Advance", so the (first) invoicing date # is the start_date # If there are no outlays(invoices) next invoicing date is start_date if outlay_type_phase_link.evalocl("self->getLinks('LnkAuslageAuslagetypphaselink_B')->size=0"): date = start_date # Special case: start date is end of month. Then the next invoicing date must also # always be at the end of the month elif is_start_date_last_of_month(outlay_type_phase_link): date = increment_date_by_accounting_interval(current_next_invoicing_date, accounting_interval) date = vtcapp.lastdayofmonth(date) else: date = increment_date_by_accounting_interval(current_next_invoicing_date, accounting_interval) else: # Charge type "In arrears", so the first invoicing date # is end of period # If there are no outlays(invoices) next invoicing date is start_date if outlay_type_phase_link.evalocl("self->getLinks('LnkAuslageAuslagetypphaselink_B')->size=0"): date = increment_date_by_accounting_interval(start_date, accounting_interval) # Decrement one day on first time date = vtcapp.incday(date,-1) else: date = increment_date_by_accounting_interval(current_next_invoicing_date, accounting_interval) # Special case 1: If start_date is on the first of the month, # we assume, that the user wants to have the invoicing date # always END of the month and not just + n month - 1 day, if start_date.day == 1: date = vtcapp.lastdayofmonth(date) # Special case 2: If start_date is on the last of the month, # we assume, that the user wants to have the invoicing date always end # of the month -1 day and not just + n month - 1 day, if is_start_date_last_of_month(outlay_type_phase_link): date = vtcapp.lastdayofmonth(date) date = vtcapp.incday(date,-1) # Set the calculated date, but only if the next invoicing date is before # than the end date (if set). Else reset the next invoicing date if outlay_type_phase_link.lic_endDate and (outlay_type_phase_link.lic_endDate< date): # Next invoicing date is later than the end date -> reset new invoicing date outlay_type_phase_link.lic_nextInvoicingDate = None else: outlay_type_phase_link.lic_nextInvoicingDate = date return def is_start_date_first_of_month(outlay_type_phase_link): """ Is start date of a service contract exactly first of month? Needed for special case handling. """ start_date = outlay_type_phase_link.lic_startDate return start_date == vtcapp.firstdayofmonth(start_date) def is_start_date_last_of_month(outlay_type_phase_link): """ Is start date of a service contract exactly at end of month? Needed for special case handling. """ start_date = outlay_type_phase_link.lic_startDate return start_date == vtcapp.lastdayofmonth(start_date) def htmlescape(object): """ Escapes HTML special characters in a string. """ # Get string representation of the object text = str(object) if not text: return "" return (text.replace("&", "&amp;") .replace("<", "&lt;") .replace(">", "&gt;") .replace('"', "&quot;")) None false true false Python2 Script_PurchasetypeChangesOnPurchasetypephaselink Event: Outlaytype changes on purchasetypephaselink auslagetypen OutlaytypePhaseLink false # coding: windows-1252 # # Designation: Outlaytype changes on purchasetypephaselink # Classes: # CondExpression: # ObjectScript: # ContainerScript: # EventType: Geändert # EventClass: AuslageTypPhaseLink # EventMembers: auslagetypen # Set default values on purchasetypephaselink # 2024-09-03, MKL: adjusting script according to PEP-8 import module_licenses module_licenses.outlaytype_changes_on_outlay_type_phase_link(argobject) Changed false false false Python2 Script_ValueChangesOnPurchasetypephaselink Event: Value changes on purchasetypephaselink planFeeOutlaysExt, feePerUnitExt,lic_discountPercentage, lic_amount, lic_discount, lic_calcPrice, lic_startDate, lic_charge_type, lic_accountingInterval, lic_endDate OutlaytypePhaseLink false # coding: windows-1252 # # Designation: Value changes on purchasetypephaselink # Classes: # CondExpression: # ObjectScript: # ContainerScript: # EventType: Geändert # EventClass: purchasetypephaselink # EventMembers: lic_amount, wertProEinheitInt, wertproeinheitext, # planWertAuslagen, lic_discountPercentage, lic_discount # Calculates rates and discounts # 2024-07-02, WCA: Rearranged the approach used for disableevents # 2024-09-03, MKL: adjusting script according to PEP-8 import module_licenses def main(): # we disable events here, because we set values that # would trigger this script as well with vtcapp.DisabledEvents(): module_licenses.value_changes_on_outlay_type_phase_link(argobject, args.eventmember) main() Changed false true false Python2 ScriptChargeLicenses Charge licenses OutlaytypePhaseLink false self->forAll(hastag('license') and phase.owningproject->isMemberWritable('invoices')) # coding: windows-1252 # # Designation: Charge licenses # Show in Vertec menus:True # Classes: OutlaytypePhaseLink # Display condition: self->forAll(hastag('license') and phase.owningproject->isMemberWritable('invoices')) # Event script for: None # Event classes: - # Event fields: - # Extended rights: False # 2024-09-03, MKL: adjusting script according to PEP-8 # 2025-04-14, AVE: Rework of config set import module_licenses # selectedobjects are BusinessClassesRoot - objects. Therefore convert to OutlaytypePhaseLink module_licenses.charge_licenses(selectedobjects.evalocl("oclAsType(OutlaytypePhaseLink)")) None false false true Python2 ScriptChargeServiceContracts Serviceverträge verrechnen OutlaytypePhaseLink false self->forAll(hastag('servicecontract') and phase.owningproject->isMemberWritable('invoices')) # coding: windows-1252 # # Designation: Serviceverträge verrechnen # Show in Vertec menus:True # Classes: OutlaytypePhaseLink # Display condition: self->forAll(hastag('servicecontract') and phase.owningproject->isMemberWritable('invoices')) # Event script for: None # Event classes: - # Event fields: - # Extended rights: False # Creates one invoice per project with one purchases for every license # without purchase entry # 2021-06-03, UHE: initial version # 2024-09-03, MKL: adjusting script according to PEP-8 # 2025-04-14, AVE: Rework of config set import module_licenses # selectedobjects are BusinessClassesRoot - objects. Therefore convert to OutlaytypePhaseLink module_licenses.charge_service_contracts(selectedobjects.evalocl("oclAsType(OutlaytypePhaseLink)")) None false false true Python2 ScriptNewLicenseSale New license sale Phase false (self->size=1) and (self->first->isMemberWritable('OutlaytypeLinks')) # coding: windows-1252 # # Designation: New license sale # Show in Vertec menus:True # Classes: Phase # Display condition: (self->size=1) and (self->first->isMemberWritable('OutlaytypeLinks')) # Event script for: None # Event classes: - # Event fields: - # Extended rights: False # Creates a new license sale on phase # 2026-04-29, AVE: Script created import module_licenses module_licenses.new_outlay_type_phase_link(argobject, 1) None false false true Python2 ScriptNewServiceContract New service contract Phase false (self->size=1) and (self->first->isMemberWritable('OutlaytypeLinks')) # coding: windows-1252 # # Designation: New service contract # Show in Vertec menus:True # Classes: Phase # Display condition: (self->size=1) and (self->first->isMemberWritable('OutlaytypeLinks')) # Event script for: None # Event classes: - # Event fields: - # Extended rights: False # Creates a new service contract on phase # 2026-04-29, AVE: Script created import module_licenses module_licenses.new_outlay_type_phase_link(argobject, 2) None false false true Python2 ScriptServiceContractSpecialInvoice Service contract: Manually invoice period self->forAll(hastag('servicecontract')) OutlaytypePhaseLink false (self->size=1) and (self->forAll(hastag('servicecontract') and phase.owningproject->isMemberWritable('invoices'))) # coding: windows-1252 # # Designation: Service contract special invoice # Show in Vertec menus:True # Classes: OutlaytypePhaseLink # Display condition: self->forAll(hastag('servicecontract')) and (self->size=1) and Usergroup.allinstances->select(entryid='UserGroupSupervisors')->first.users->includes(Timsession.allInstances->first.login) # Event script for: None # Event classes: - # Event fields: self->forAll(hastag('servicecontract')) # Extended rights: False # 2025-06, AVE: Script created import module_licenses # selectedobjects are BusinessClassesRoot - objects. Therefore convert to OutlaytypePhaseLink module_licenses.charge_service_contracts(selectedobjects.evalocl("oclAsType(OutlaytypePhaseLink)"), True) None false false false Python3 FolderAnnualOverviewServiceContracts Annual overview of service contracts 66 120 false false CurrentView 17 false false 0 0 false true 1 Client true 180 false false false 0 1 clgreen false false 0 true 3 false false false 1 10 if encodedate(varYear->round, 8, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 8, 1)) false 0 August true 65 false false false 1 11 if encodedate(varYear->round, 9, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 9, 1)) false 0 September true 65 false false false 1 12 if encodedate(varYear->round, 10, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 10, 1)) false 0 October true 65 false false false 1 13 if encodedate(varYear->round, 11, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 11, 1)) false 0 November true 65 false false false 1 14 if encodedate(varYear->round, 12, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 12, 1)) false 0 December true 65 false false false 0 2 false Currency.allinstances->first.leitwaehrung false 0 Currency true 60 false false false 1 3 if encodedate(varYear->round, 1, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 1, 1)) false 0 January true 65 false false false 1 4 if encodedate(varYear->round, 2, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 2, 1)) false 0 February true 65 false false false 1 5 if encodedate(varYear->round, 3, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 3, 1)) false 0 March true 65 false false false 1 6 if encodedate(varYear->round, 4, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 4, 1)) false 0 April true 65 false false false 1 7 if encodedate(varYear->round, 5, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 5, 1)) false 0 May true 65 false false false 1 8 if encodedate(varYear->round, 6, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 6, 1)) false 0 June true 65 false false false 1 9 if encodedate(varYear->round, 7, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_service_contracts', encodedate(varYear->round, 7, 1)) false 0 July true 65 false false false Address {"IsInstantSearch":true,"DisableShowInactive":true,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"/* We search customers which have service contracts... */\r\nbold_id IN\r\n(SELECT customer FROM project\r\n\tWHERE bold_id IN\r\n\t (SELECT project FROM phase\r\n\t WHERE bold_id IN\r\n\t\t (SELECT phase FROM outlaytypephaselink\r\n\t\t WHERE outlaytype IN\r\n\t\t (SELECT entry FROM customfielditem\r\n\t\t WHERE customfield IN\r\n\t\t\t (SELECT bold_id FROM customfield\r\n\t\t\t WHERE entryid = 'CustomfieldKindOfPurchaseType')\r\n\t\t\t AND integervalue = 2))\r\n )\r\n\t/* Already charged (Outlay in the selected year) ? */\r\n\tAND bold_id IN\r\n\t\t(SELECT project FROM phase\r\n\t\t WHERE bold_id IN\r\n\t\t (SELECT phase FROM outlaytypephaselink\r\n\t\t /* Outlay in the selected year */\r\n\t\t WHERE bold_id IN (SELECT CustomLinks FROM CustomLink WHERE fromCustomLinks IN (SELECT bold_id FROM openOutlay \r\n\t\t\t WHERE entrydate >= CAST(REPLACE('XXXX-01-01', 'XXXX', '\\1') AS date)\r\n\t\t\t\t AND entrydate <= CAST(REPLACE('XXXX-12-31', 'XXXX', '\\1') AS date))) \r\n\t\t OR bold_id IN (SELECT CustomLinks FROM CustomLink WHERE fromCustomLinks IN (SELECT bold_id FROM chargedOutlay \r\n\t\t\t WHERE entrydate >= CAST(REPLACE('XXXX-01-01', 'XXXX', '\\1') AS date)\r\n\t\t\t\t AND entrydate <= CAST(REPLACE('XXXX-12-31', 'XXXX', '\\1') AS date)))\r\n\t\t ) \r\n\t\t)\t\r\n)","SearchFields":[{"Name":"Year","Type":1,"Default":"date.year"}]}]} false true FolderAnnualOverviewSoldLicenses Annual overview of sold licenses 66 110 false false CurrentView 17 false false 0 0 false true 1 Client true 180 false false false 0 1 clgreen false false 0 true 3 false false false 1 10 if encodedate(varYear->round, 8, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 8, 1)) false 0 August true 65 false false false 1 11 if encodedate(varYear->round, 9, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 9, 1)) false 0 September true 65 false false false 1 12 if encodedate(varYear->round, 10, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 10, 1)) false 0 October true 65 false false false 1 13 if encodedate(varYear->round, 11, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 11, 1)) false 0 November true 65 false false false 1 14 if encodedate(varYear->round, 12, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 12, 1)) false 0 December true 65 false false false 0 2 false Currency.allinstances->first.leitwaehrung false 0 Currency true 60 false false false 1 3 if encodedate(varYear->round, 1, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 1, 1)) false 0 January true 65 false false false 1 4 if encodedate(varYear->round, 2, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 2, 1)) false 0 February true 65 false false false 1 5 if encodedate(varYear->round, 3, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 3, 1)) false 0 March true 65 false false false 1 6 if encodedate(varYear->round, 4, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 4, 1)) false 0 April true 65 false false false 1 7 if encodedate(varYear->round, 5, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 5, 1)) false 0 May true 65 false false false 1 8 if encodedate(varYear->round, 6, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 6, 1)) false 0 June true 65 false false false 1 9 if encodedate(varYear->round, 7, 1)>=date then 'clnavy' else 'clwindowtext' endif true self->callCurrDate('module_licenses.get_amount_licenses', encodedate(varYear->round, 7, 1)) false 0 July true 65 false false false Address {"IsInstantSearch":true,"DisableShowInactive":true,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"/* Select by customer */\r\nbold_id IN\r\n(SELECT customer FROM project\r\n WHERE bold_id IN\r\n (SELECT project FROM phase WHERE bold_id IN\r\n\t (SELECT phase FROM outlaytypephaselink\r\n\t WHERE outlaytype IN\r\n\t (SELECT entry FROM customfielditem\r\n\t WHERE customfield IN\r\n (SELECT bold_id FROM customfield WHERE entryid = 'CustomfieldKindOfPurchaseType')\r\n\t AND integervalue = 1)\r\n /* and select year. We use a general SQL-query that works in Firebird and MSSQL */\r\n AND\r\n bold_id IN\r\n (SELECT entry FROM customfielditem\r\n WHERE customfield IN (SELECT bold_id FROM customfield WHERE entryid='AdditionalField_LicStartdate')\r\n AND datevalue<=CAST(REPLACE('XXXX-12-31', 'XXXX', '\\1') as date)\r\n AND datevalue>=CAST(REPLACE('XXXX-01-01', 'XXXX', '\\1') as date)\r\n )\r\n /* Already charged (query for link) ? */\r\n AND \r\n ( bold_id in (SELECT CustomLinks FROM CustomLink WHERE fromCustomLinks \r\n IN (SELECT bold_id FROM chargedOutlay WHERE 1=1))\r\n\tOR \r\n\t bold_id in (SELECT CustomLinks FROM CustomLink WHERE fromCustomLinks \r\n\t IN(SELECT bold_id FROM openOutlay WHERE 1=1))\r\n )\r\n ))\r\n)","SearchFields":[{"Name":"Year","Type":1,"Default":"date.year"}]}]} false true FolderInvoicingLicenseSale Licence invoices 9 1040 false true CurrentView 17 false false 0 0 false entryDate false 1 Date true 60 false false false 0 1 false number true 0 ID-Number true 100 false false false 0 2 false project.customer false 0 Client true 120 false false false 0 3 false project.code true 0 Project true 120 false false false 0 4 rndTranslate false if charged then 'definitive' else 'provisional' endif true 0 Status true 75 false false false 1 5 true total false 0 Total amount true 80 false false false 0 6 false outlays->select(type.zusatzfeldint('lic_kindOfOutlayType')>0)->getLinks('LnkAuslageAuslagetypphaselink_A')->size false 0 License sale true 90 false false false Rechnung {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"projekt in (select bold_id from projekt where ((code like '\\2') and ('\\1'='' or kunde in (select bold_id from adresseintrag where name like '%\\1%' or alias like '%\\1%')))) and\r\n\r\n(bold_id in (select rechnung from offeneauslage where typ in (select usereintrag from zusatzfeld where metazusatzfeld in \r\n(select bold_id from zusatzfeldklasse where eintragid = 'CustomfieldKindOfPurchaseType') and wertinteger = 1)) or \r\nbold_id in (select rechnung from verrechneteauslage where typ in (select usereintrag from zusatzfeld where metazusatzfeld in \r\n(select bold_id from zusatzfeldklasse where eintragid = 'AdditionalField_LicKindPurchaseType') and wertinteger = 1))) and\r\n\r\n('\\3'='' or datum >= '\\3') and ('\\4'='' or datum <= '\\4') ","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"From date","Type":2,"Default":"date.firstofmonth"},{"Name":"To date","Type":2,"Default":"date.lastofmonth"}]}]} false true FolderInvoicingServiceContracts Invoices service contracts 9 1050 false true CurrentView 17 false false 0 0 false entryDate false 1 Date true 60 false false false 0 1 false number true 0 ID-Number true 100 false false false 0 2 false projekt.customer false 0 Client true 120 false false false 0 3 false project.code true 0 Project true 120 false false false 0 4 rndTranslate false if charged then 'definitive' else 'provisional' endif true 0 Status true 75 false false false 1 5 true total false 0 Total amount true 80 false false false 0 6 false outlays->select(type.zusatzfeldint('lic_kindOfOutlayType')>0)->getLinks('LnkAuslageAuslagetypphaselink_A')->size false 0 Service contracts true 90 false false false Rechnung {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"projekt in (select bold_id from projekt where ((code like '\\2') and ('\\1'='' or kunde in (select bold_id from adresseintrag where name like '%\\1%' or alias like '%\\1%')))) and\r\n\r\n(bold_id in (select rechnung from offeneauslage where typ in (select usereintrag from zusatzfeld where metazusatzfeld in \r\n(select bold_id from zusatzfeldklasse where eintragid = 'CustomfieldKindOfPurchaseType') and wertinteger = 2)) or \r\nbold_id in (select rechnung from verrechneteauslage where typ in (select usereintrag from zusatzfeld where metazusatzfeld in \r\n(select bold_id from zusatzfeldklasse where eintragid = 'AdditionalField_LicKindPurchaseType') and wertinteger = 2))) and\r\n\r\n\r\n('\\3'='' or datum >= '\\3') and ('\\4'='' or datum <= '\\4') ","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"From date","Type":2,"Default":"date.firstofmonth"},{"Name":"To date","Type":2,"Default":"date.lastofmonth"}]}]} false true FolderLicenseSales License sale 85 20 false true CurrentView 17 true true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 10 true customfieldcurr('lic_discount') false 0 Discount amount true 70 false false false 1 11 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 12 clgreen false '' false 0 true 3 false false false 1 13 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 14 false planFeeOutlaysExt false 0 Total true 60 false false false 0 15 clGreen false '' false 0 true 3 false false false 0 16 false <DatePicker/> customfielddate('lic_startDate') false 0 Purchase date true 81 false false false 0 17 false getlinks('LnkAuslageAuslagetypphaselink_B') ->oclastype(Outlay).feeext->sum false 0 Charged true 100 false false false 0 2 false outlaytype.customfieldAsString('lic_product') false 0 Product true 100 false false false 0 3 if (phase.status<1) or (phase.status>2) then 'clYellow' else '' endif false phase.status false 0 Phase status true 80 false false false 0 4 false designation false 0 Designation true 120 false false false 0 6 clGreen false '' false 0 true 3 false false false 0 7 false phase.owningProject.currency false 0 Currency true 60 false false false 1 8 false feePerUnitExt false 0 Selling price true 70 false false false 1 9 false customfieldcurr('lic_discountPercentage') false 0 Discount % true 70 false false false OutlaytypePhaseLink {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"/* Filter by client OR project */\r\nphasen IN (\r\n SELECT bold_id FROM phase\r\n WHERE project IN (\r\n SELECT bold_id FROM project\r\n WHERE (code LIKE '\\2')\r\n AND ('\\1' = '' OR customer IN (\r\n SELECT bold_id FROM address\r\n WHERE name LIKE '%\\1%' OR alias LIKE '%\\1%'\r\n ))\r\n )\r\n/* Phase ordered ? */\r\nAND ('\\6' = 0 or status IN (1,2)) \r\n)\r\nAND \r\noutlaytype IN (SELECT entry from CustomFieldItem WHERE customfield IN \r\n(SELECT bold_id from CustomField WHERE entryid = 'CustomfieldKindOfPurchaseType') AND integervalue = 1) \r\nAND\r\n(outlaytype IN (SELECT entry FROM CustomFieldItem WHERE customfield IN (SELECT bold_id from CustomField WHERE entryid='AdditionalField_LicProduct') \r\nAND\r\nobjectvalue IN (SELECT entry from CustomFieldItem WHERE customfield IN (SELECT bold_id from CustomField WHERE entryid = 'cc26CustomfieldProductName') AND stringvalue = '\\3')) OR ('\\3'='')) \r\nAND \r\n(bold_id IN (SELECT entry FROM CustomFieldItem WHERE customfield IN (SELECT bold_id from CustomField WHERE entryid='AdditionalField_LicStartdate') \r\nAND\r\n('\\4'='' OR datevalue >= '\\4') AND ('\\5'='' OR datevalue<='\\5')) OR ('\\4'='' AND '\\5'=''))","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"Product","Type":5,"Expression":"''->union(ConfigSetCustomClass26.allinstances->orderby(customfield('cc26_licProductname')).customfield('cc26_licProductname'))"},{"Name":"From date","Type":2},{"Name":"To date","Type":2},{"Name":"Only ordered phases","Type":3,"Default":"0"}]}]} false true FolderSalesProjectsLicenseSaleAndServiceContracts Projects license sale and service contracts 6 10 false true CurrentView 17 false false 0 0 false code true 1 Project-code true 102 false false false 0 1 false beschrieb true 0 Project description true 164 false false false 0 2 false betreffend true 0 Regarding true 149 false false false 0 3 false typ false 0 Project type true 80 false false false 0 4 false projektleiter false 0 Project manager true 90 false false false 0 5 false phases.getlinks('LnkPhaseLicenseSale_A') ->size false 0 License sale true 90 false false false 0 6 false phasen.getlinks('LnkPhaseServiceContracts_A')->size false 0 Serviceverträge true 90 false false false Project Projekt {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"bold_id in (select projekt from Projektphase where bold_id in (select phasen from auslagetypphaselink where auslagetypen in (select usereintrag from zusatzfeld where metazusatzfeld in \r\n(select bold_id from zusatzfeldklasse where eintragid = 'CustomfieldKindOfPurchaseType') and ((wertinteger = 1) or (wertinteger = 2)))))"}]} true false FolderServiceContracts Serviceverträge 85 30 false true CurrentView 17 false true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 10 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 11 false planFeeOutlaysExt false 0 Total true 60 false false false 0 12 clGreen false '' false 0 true 3 false false false 0 13 false <DatePicker/> customfielddate('lic_startDate') false 0 Start date true 60 false false false 0 14 if customfielddate('lic_endDate').notNull then 'clYellow' else '' endif false customfielddate('lic_endDate') false 0 End date true 73 false false false 0 15 cmbzusatzfeld rndzusatzfeld false customfieldint('lic_accountingInterval') false 0 Invoice period true 95 false false false 0 16 false zusatzfeldasstring('lic_charge_type') false 0 Charge type true 90 false false false 0 17 false customfielddate('lic_nextInvoicingDate') false 0 Next invoicing true 110 false false false 0 18 false getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Auslage).rechnung->orderby(datum)->last.datum false 0 Date of last invoice true 115 false false false 1 19 false getlinks('LnkAuslageAuslagetypphaselink_B') ->oclastype(Outlay).feeext->sum false 0 Total turnover true 80 false false false 0 2 false outlaytype.customfieldasstring('lic_product') false 0 Product true 100 false false false 0 3 if (phase.status<1) or (phase.status>2) then 'clYellow' else '' endif false phase.status false 0 Phase status true 80 false false false 0 4 false designation false 0 Designation true 120 false false false 0 5 clGreen false '' false 0 true 3 false false false 0 6 false phase.owningproject.currency false 0 Currency true 60 false false false 1 7 false feePerUnitExt false 0 Selling price true 70 false false false 1 8 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 9 clgreen false '' false 0 true 3 false false false OutlaytypePhaseLink {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Neue Abfrage","Template":"/* Filter by client OR project */\r\nphasen IN (\r\n SELECT bold_id FROM phase\r\n WHERE project IN (\r\n SELECT bold_id FROM project\r\n WHERE (code LIKE '\\2')\r\n AND ('\\1' = '' OR customer IN (\r\n SELECT bold_id FROM address\r\n WHERE name LIKE '%\\1%' OR alias LIKE '%\\1%'\r\n ))\r\n )\r\n /* Phase ordered ? */\r\n AND ('\\5'=0 OR status IN (1,2))\r\n)\r\nAND\r\n/* Filter: service contracts only (kind = 2) */\r\noutlaytype IN (\r\n SELECT entry FROM customfielditem\r\n WHERE customfield IN (\r\n SELECT bold_id FROM customfield\r\n WHERE entryid = 'CustomfieldKindOfPurchaseType')\r\n AND integervalue = 2\r\n)\r\nAND\r\n/* Filter by product */\r\n(outlaytype IN \r\n\t(SELECT entry FROM customfielditem\r\n\t WHERE customfield IN \r\n\t (SELECT bold_id FROM customfield WHERE entryid = 'AdditionalField_LicProduct') \r\n\t AND wertobject in \r\n\t (SELECT entry FROM customfielditem WHERE customfield IN \r\n\t (SELECT bold_id FROM customfield \r\n\t\t WHERE entryid = 'cc26CustomfieldProductName') \r\n AND stringvalue = '\\3')\r\n\t) \r\nOR ('\\3'='')\r\n) \r\nAND\r\n/* Filter by keydate: contract must have started */\r\nbold_id IN (\r\n SELECT entry FROM customfielditem\r\n WHERE customfield IN (\r\n SELECT bold_id FROM customfield\r\n WHERE entryid = 'AdditionalField_LicStartdate')\r\n AND ('\\4' = '' OR datevalue <= '\\4')\r\n)\r\nAND\r\n/* Filter by end date: contract must not have ended before keydate */\r\nbold_id IN (\r\n SELECT entry FROM customfielditem\r\n WHERE customfield IN (\r\n SELECT bold_id FROM customfield\r\n WHERE entryid = 'AdditionalField_LicEnddate')\r\n AND ('\\4' = '' OR datevalue >= '\\4' OR datevalue IS NULL)\r\n )","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"Product","Type":5,"Expression":"''->union(ConfigSetCustomClass26.allinstances->orderby(customfield('cc26_licProductname')).customfield('cc26_licProductname'))"},{"Name":"Effective date","Type":2},{"Name":"Only ordered phases","Type":3,"Default":"0"}]}]} false true SqlfolderLicensesToInvoice Licenses to invoice 85 60 false false CurrentView 17 true true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 12 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 13 clgreen false '' false 0 true 3 false false false 1 14 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 15 false planFeeOutlaysExt false 0 Total true 60 false false false 0 16 clGreen false '' false 0 true 3 false false false 0 17 false <DatePicker/> customfielddate('lic_startDate') false 0 Purchase date true 81 false false false 0 3 false outlaytype.customfieldAsString('lic_product') false 0 Product true 100 false false false 0 4 if (phase.status<1) or (phase.status>2) then 'clYellow' else '' endif false phase.status false 0 Phase status true 80 false false false 0 5 clGreen false '' false 0 true 3 false false false 0 6 false phase.owningProject.currency false 0 Currency true 60 false false false 1 9 false feePerUnitExt false 0 Selling price true 70 false false false OutlaytypePhaseLink {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Search Form","Template":"phase IN (SELECT bold_id from phase WHERE project\r\n\tIN (SELECT bold_id from project WHERE ((code like '\\2')\r\n AND ('\\1'='' OR customer IN (SELECT bold_id from address WHERE name like '%\\1%' OR alias like '%\\1%'))))\r\n\t/* Phase ordered? */\r\n\tAND ('\\4'=0 or status IN (1,2)))\r\nAND outlaytype IN (SELECT entry from customfielditem WHERE customfield\r\n\tIN (SELECT bold_id from customfield WHERE entryid = 'CustomfieldKindOfPurchaseType') AND integervalue = 1)\r\nAND (outlaytype IN (SELECT entry FROM customfielditem WHERE customfield IN (SELECT bold_id from customfield WHERE entryid='AdditionalField_LicProduct')\r\n AND objectvalue IN (SELECT entry from customfielditem WHERE customfield IN (SELECT bold_id from customfield WHERE entryid = 'cc26CustomfieldProductName') AND stringvalue = '\\3')) OR ('\\3'=''))\r\n/* And already ordered (has start/sales date) */\r\nAND\r\nbold_id IN\r\n(\r\n SELECT entry FROM customfielditem WHERE customfield IN (SELECT bold_id FROM customfield\r\n WHERE entryid='AdditionalField_LicStartdate') AND datevalue IS NOT NULL\r\n)\r\n/* ...and only show licenses without outlays (=not yet invoiced): */\r\nAND\r\nbold_id NOT IN\r\n(SELECT customlinks FROM customlink WHERE linktype IN (SELECT bold_id FROM linktype WHERE entryid ='LnkAuslageAuslagetypphaselink'))\r\n","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"Product","Type":5,"Expression":"''->union(ConfigSetCustomClass26.allinstances->orderby(customfield('cc26_licProductname')).customfield('cc26_licProductname'))"},{"Name":"Only ordered phases","Type":3,"Default":"0"}]}]} false true SqlfolderServicescontractsToInvoice Service contracts to invoice 85 70 false false CurrentView 17 true true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 10 false planFeeOutlaysExt false 0 Total true 60 false false false 0 11 clGreen false '' false 0 true 3 false false false 0 12 false <DatePicker/> customfielddate('lic_startDate') false 0 Start date true 60 false false false 0 13 if customfielddate('lic_endDate').notNull then 'clYellow' else '' endif false customfielddate('lic_endDate') false 0 End date true 73 false false false 0 14 cmbzusatzfeld rndzusatzfeld false customfieldint('lic_accountingInterval') false 0 Invoice period true 100 false false false 0 15 false zusatzfeldasstring('lic_charge_type') false 0 Charge type true 100 false false false 0 16 false customfielddate('lic_nextInvoicingDate') false 0 Next invoicing true 106 false false false 0 17 false getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Auslage).rechnung->orderby(datum)->last.datum false 0 Date of last invoice true 115 false false false 0 2 false outlaytype.customfieldasstring('lic_product') false 0 Product true 100 false false false 0 3 if (phase.status<1) or (phase.status>2) then 'clYellow' else '' endif false phase.status false 0 Phase status true 80 false false false 0 4 clGreen false '' false 0 true 3 false false false 0 5 false phase.owningproject.currency false 0 Currency true 60 false false false 1 6 false feePerUnitExt false 0 Selling price true 70 false false false 1 7 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 8 clgreen false '' false 0 true 3 false false false 1 9 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false OutlaytypePhaseLink {"IsInstantSearch":false,"DisableShowInactive":false,"SearchDefinitions":[{"Name":"Search form","Template":"/* Filter by the entered parameters (phase, service contract type, license product) */\r\nphase IN (SELECT bold_id FROM phase WHERE project IN (SELECT bold_id FROM project WHERE ((code LIKE '\\2') \r\n AND ('\\1'='' or customer IN (SELECT bold_id FROM address WHERE name LIKE '%\\1%' or alias LIKE '%\\1%'))))\r\n /* Phase ordered? */\r\n AND ('\\5'=0 OR status IN (1,2)))\r\nAND\r\n(outlaytype IN (SELECT entry FROM customfielditem WHERE customfield IN \r\n (SELECT bold_id FROM customfield WHERE entryid = 'CustomfieldKindOfPurchaseType') AND integervalue = 2)) \r\nAND\r\n(outlaytype in (SELECT entry FROM customfielditem WHERE customfield IN \r\n (select bold_id FROM customfield WHERE entryid='AdditionalField_LicProduct') \r\n AND objectvalue IN (SELECT entry FROM customfielditem \r\n WHERE customfield IN (SELECT bold_id FROM customfield \r\n WHERE entryid = 'cc26CustomfieldProductName') \r\n AND stringvalue = '\\3')) OR ('\\3'='')) \r\nAND\r\n/* Add contracts where the next invoicing date is before the entered date and date is set*/\r\n(\t'\\4'=\"\" \r\nOR\r\n\tbold_id IN \r\n\t(\r\n\t SELECT entry FROM customfielditem WHERE customfield IN (SELECT bold_id FROM customfield\r\n\t WHERE entryid='CustomfieldLicNextinvoicingdate') AND (datevalue <= '\\4' AND datevalue IS NOT NULL) \r\n\t)\r\n)\r\nAND \r\n/* Exclude cancelled contracts, where the next invoicing date will be after der end date */\r\nbold_id not IN\r\n( \r\n\tSELECT z1.entry\r\n\tFROM customfielditem z1\r\n\tWHERE z1.customfield IN \r\n\t(\r\n\t SELECT bold_id FROM customfield\r\n\t WHERE fieldname = 'lic_nextInvoicingDate'\r\n\t)\r\n\tAND z1.datevalue > \r\n\t\t(\r\n\t\t SELECT z2.datevalue FROM customfielditem z2\r\n\t\t WHERE z2.customfield IN \r\n\t\t(\r\n\t\t SELECT bold_id FROM customfield\r\n\t\t WHERE fieldname = 'lic_endDate'\r\n\t\t)\r\n\tAND z2.entry = z1.entry \r\n )\r\n)","SearchFields":[{"Name":"Client","Type":0},{"Name":"Project","Type":0},{"Name":"Product","Type":5,"Expression":"''->union(ConfigSetCustomClass26.allinstances->orderby(customfield('cc26_licProductname')).customfield('cc26_licProductname'))"},{"Name":"To date","Type":2,"Default":"date"},{"Name":"Only ordered phases","Type":3,"Default":"0"}]}]} false true TranslationAnnualOverviewOfSoldLicenses Jahresübersicht verkaufte Lizenzen Annual overview of sold licenses Aperçu annuel des licenses vendues Panoramica annuale delle licenze vendute Jahresübersicht verkaufte Lizenzen Jaarlijks overzicht van verkochte licenties Annual overview of sold licenses TranslationChargeLicenses Lizenzen verrechnen Charge licenses Attribuer des licenses Assegnare le licenze Lizenzen verrechnen Heffingslicenties Charge licenses TranslationInAdvance Im Voraus In advance À l’avance In anticipo Vorschüssig Op voorhand In advance TranslationInArrears Im Nachhinein In arrears A posteriori A posteriori Nachschüssig Achterstallige betalingen In arrears TranslationInvoiceLicensesAndServiceContracts Rechnung Lizenzen und Serviceverträge Invoice licenses and service contracts Facture les licences et les contrats de service Fattura licenze e contratti di servizio Rechnung Lizenzen und Serviceverträge Factuurlicenties en servicecontracten Invoice licenses and service contracts TranslationInvoicesToBeGenerated Zu erstellende Rechnungen Invoices to be generated Factures à générer Fatture da generare Zu erstellende Rechnungen Te genereren facturen Invoices to be generated TranslationItemLicensedProduct Lizenzprodukt Licensed product Produit sous license Prodotto con licenza Lizenzprodukt Gelicentieerd product Licensed product TranslationKindOfOutlayType Art Auslagentyp Kind of outlay type Genre type dépenses Genere di tipo esborso Art Auslagentyp Soort uitgaven Kind of outlay type TranslationLicenseProducts Lizenzprodukte Licensed products Produits sous license Prodotti di licenza Lizenzprodukte Gelicentieerde producten Licensed products TranslationLicenseSale Lizenzverkauf License sale Vente de licences Vendita di licenze Lizenzverkauf Licentieverkoop License sale TranslationLicenseSaleAndServiceContracts Lizenzverkauf und Serviceverträge License sale and service contracts Contrats de vente de licenses et de services Contratti di vendita di licenze e di servizi Lizenzverkauf und Serviceverträge Licentieverkoop- en servicecontracten License sale and service contracts TranslationLicenseSales Lizenzverkäufe License sales Ventes de licenses Vendite di licenze Lizenzverkäufe Licentieverkoop License sales TranslationLicensesToInvoice Lizenzen zum Verrechnen Licenses to invoice Licenses de facturation Licenze per fatturare Lizenzen zum Verrechnen Vergunningen te factureren Licenses to invoice TranslationNewLicenseSale Neuer Lizenzverkauf New license sale Vente d’une nouvelle license Vendita di nuove licenze Neuer Lizenzverkauf Nieuwe licentieverkoop New license sale TranslationNewServiceContract Neuer Servicevertrag New service contract Nouveau contrat de service Nuovo contratto di servizio Neuer Servicevertrag Nieuw dienstencontract New service contract TranslationNextBilling Nächste Verrechnung Next invoicing Prochaine facturation Prossima fatturazione Nächste Verrechnung Volgende facturatie Next invoicing TranslationNoLicensesAvailableForInvoicing Keine Lizenzen zur Verrechnung vorhanden. No licenses available for invoicing. Aucune license disponible pour la facturation. Nessuna licenza disponibile per la fatturazione. Keine Lizenzen zur Verrechnung vorhanden. Geen licenties beschikbaar voor facturering. No licenses available for invoicing. TranslationNoServiceContractsAvailableForInvoicing Keine Serviceverträge zur Verrechnung vorhanden. No service contracts available for invoicing. Il n’y a pas de contrats pour la facturation. Non ci sono contratti per la fatturazione. Es gibt keine Verträge zur Verrechnung. Geen servicecontracten beschikbaar voor facturering. No service contracts available for invoicing. TranslationNotConsidered Nicht berücksichtigt Not considered Non pris en compte Non considerato Nicht berücksichtigt Niet in aanmerking genomen Not considered TranslationNumberOfServiceContracts Anzahl Serviceverträge Number of service contracts Nombre de contrats de service Numero di contratti di servizio Anzahl Serviceverträge Aantal dienstencontracten Number of service contracts TranslationOnlyOrderedPhases Nur bestellte Phasen Only ordered phases Seules phases commandées Solo fasi ordinate Nur bestellte Phasen Alleen bestelde fasen Only ordered phases TranslationPercentageOfLicenseTotal % von Lizenzbetrag % of license total % du montant de la licence % dell'importo della licenza % von Lizenzbetrag % van het totaal aantal vergunningen % of license total TranslationPeriodStart Beginn der Periode Period start Début de la période Inizio del periodo Beginn der Periode Begin van de periode Period start TranslationPhaseStatus Phasenstatus Phase status Statut de phase Stato di fase Phasenstatus Fasestatus Phase status TranslationProjectsLicenseSaleAndServiceContracts Projekte Lizenzverkauf und Serviceverträge Projects license sale and service contracts Projets vente de licenses et contrats de service Progetti vendita di licenze e contratti di servizio Projekte Lizenzverkauf und Serviceverträge Projecten licentieverkoop- en servicecontracten Projects license sale and service contracts TranslationServiceContractSpecialInvoice Servicevertrag: Periode manuell verrechnen Service contract: Manually invoice period Contrat de services: Période de facturation manuelle Contratto di servizi: Periodo di fatturazione manuale Servicevertrag: Periode manuell verrechnen Serviceovereenkomst: Handmatig factureren per periode Service contract: Manually invoice period TranslationServicescontractsToInvoice Serviceverträge zum Verrechnen Service contracts to invoice Contrats de services à facturer Servizicontratti a fattura Serviceverträge zum Verrechnen Te factureren dienstencontracten Service contracts to invoice LnkInvoiceOutlays true true false false 300 false false Outlay 48 DateFilterContainer Purchases true false CurrentView 17 true true 0 1 cmbProject false project false 1 Project true 70 false false false 1 10 rndCascCurrency true feeext false 0 Total sales true 80 false false false 0 11 false text false 0 Text true 326 false false true project.language 0 2 cmbPhase false phase false 0 Phase true 70 false false false 0 3 false entryDate false 0 Date false 60 false false false 0 4 cmbExpenditureUser false user false 0 User false 65 false false false 0 5 cmbExpenditureTypes false type false 0 Type true 56 false false false 1 6 false quantity false 0 Quantity true 60 false false false 1 7 false feePerUnitInt false 0 Purchase price true 80 false false false 1 8 true feePerUnitExt false 0 Selling price true 80 false false false 1 9 false feeint false 0 Total purchases true 80 false false false outlays false false false 0 false false Invoice 9 WrapperLinkContainer Invoice true true CurrentView invoice false LnkLicenseSaleAndServiceContractsInvoices true true true false 0 false false Invoice 9 WrapperLinkContainer Invoices true true CurrentView self->getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Outlay) ->select(type.zusatzfeldint('lic_kindOfOutlayType')>0).invoice false false false 0 false false OutlaytypePhaseLink 85 WrapperLinkContainer License sale and service contracts true true CurrentView outlays->select(type.zusatzfeldint('lic_kindOfOutlayType')>0)->getLinks('LnkAuslageAuslagetypphaselink_A') false LnkPhaseLicenseSale true true false false 0 false false auslagetypphaselink OutlaytypePhaseLink 85 WrapperLinkContainer License sale true true CurrentView 17 false true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 1 12 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false 0 13 clgreen false '' false 0 true 3 false false false 1 14 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 15 false planFeeOutlaysExt false 0 Total true 60 false false false 0 16 clGreen false '' false 0 true 3 false false false 0 17 false <DatePicker/> customfielddate('lic_startDate') false 0 Purchase date true 78 false false false 1 22 false planFeeOutlaysExt false 0 Charged true 60 false false false 0 3 false outlaytype.customfieldAsString('lic_product') false 0 Product true 80 false false false 0 4 false designation false 0 Designation true 120 false false false 0 5 clGreen false '' false 0 true 3 false false false 0 6 false phase.owningProject.currency false 0 Currency true 60 false false false 1 7 false feePerUnitInt false 0 Purchase price true 80 false false false 1 8 false outlaytype.feePerUnitExt true 0 List selling price true 95 false false false 1 9 false feePerUnitExt false 0 Selling price true 70 false false false auslagetypphaselink->select(auslagetypen.zusatzfeldint('lic_kindOfOutlayType')=1) false false false 0 false false Phase -1 WrapperLinkContainer Phase false true CurrentView phasen false LnkPhaseOutlaytypeLink true true true false 300 true false auslagetypphaselink OutlaytypePhaseLink 49 WrapperLinkContainer Auslagentypen true true CurrentView 17 true true 0 1 cmbType false outlaytype false 1 Purchase type true 120 false false false 0 2 cmbUser false user false 0 User true 100 false false false 1 3 true planFeeOutlaysExt false 0 Budget false 70 false false false 1 4 true phase.outlays.list->oclAsType(Outlay)->select(typ=self.outlaytype)->select(status=0).fee->sum false 0 Planned false 70 false false false 1 5 true phase.outlays.list->oclAsType(Outlay)->select(typ=self.outlaytype)->select(status=1).fee->sum false 0 Ordered false 70 false false false 1 6 true phase.outlays.list->oclAsType(Outlay)->select(typ=self.outlaytype)->select(status=2).fee->sum false 0 Invoice arrived false 115 false false false 1 7 true phase.outlays.list->oclAsType(Outlay)->select(typ=self.outlaytype).fee->sum false 0 Total true 70 false false false auslagetypphaselink->reject(auslagetypen.zusatzfeldint('lic_kindOfOutlayType')>0) false false false 0 false false Phase -1 WrapperLinkContainer Phasen false true CurrentView phasen false LnkPhaseServiceContracts true true false false 0 false false auslagetypphaselink OutlaytypePhaseLink 85 WrapperLinkContainer Service contracts true true CurrentView 17 false true 0 0 false phase.phasegetprojekt.customer false 0 Client true 100 false false false 0 1 false phase.phasegetprojekt false 0 Project true 100 false false false 0 10 clgreen false '' false 0 true 3 false false false 1 11 true customfieldcurr('lic_amount') false 0 Quantity true 50 false false false 1 12 false planFeeOutlaysExt false 0 Total true 60 false false false 0 13 clGreen false '' false 0 true 3 false false false 0 14 false <DatePicker/> customfielddate('lic_startDate') false 0 Start date true 60 false false false 0 15 if customfielddate('lic_endDate').notNull then 'clYellow' else '' endif false customfielddate('lic_endDate') false 0 End date true 73 false false false 0 16 cmbzusatzfeld rndzusatzfeld false customfieldint('lic_accountingInterval') false 0 Invoice period true 95 false false false 0 17 false zusatzfeldasstring('lic_charge_type') false 0 Charge type true 90 false false false 0 18 false customfielddate('lic_nextInvoicingDate') false 0 Next invoicing true 110 false false false 0 19 false getlinks('LnkAuslageAuslagetypphaselink_B').oclastype(Auslage).rechnung->orderby(datum)->last.datum false 0 Date of last invoice true 115 false false false 0 2 false outlaytype.customfieldasstring('lic_product') false 0 Product true 80 false false false 1 20 false getlinks('LnkAuslageAuslagetypphaselink_B') ->oclastype(Outlay).feeext->sum false 0 Total turnover true 80 false false false 0 3 false designation false 0 Designation true 120 false false false 0 4 clGreen false '' false 0 true 3 false false false 0 5 false phase.owningproject.currency false 0 Currency true 60 false false false 1 6 false feePerUnitInt false 0 Purchase price true 80 false false false 1 7 false outlaytype.feePerUnitExt true 0 List selling price true 95 false false false 1 8 false feePerUnitExt false 0 Selling price true 70 false false false 1 9 true feePerUnitExt-customfieldcurr('lic_discount') false 0 Price incl. discount false 95 false false false auslagetypphaselink->select(auslagetypen.zusatzfeldint('lic_kindOfOutlayType')=2) false false false 0 false false Phase -1 WrapperLinkContainer Phase false true CurrentView phasen false true false 780 true false UserRight 101 WrapperLinkContainer Authorizations true false CurrentView rights false