static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
HelperHouseManagementService helperHouseManagementService = new HelperHouseManagementService();
HelperOrganizationRegistryCommonService helperOrganizationRegistryCommonService = new HelperOrganizationRegistryCommonService();
HelperBillService helperBillService = new HelperBillService();
string typeRes = null;
do
{
foreach (var tmpSupplyResourceContract in helperHouseManagementService.GetSupplyResourceContractData(_orgPPAGUID, _ExportContractRootGUID).exportSupplyResourceContractResult.Items)
{
typeRes = tmpSupplyResourceContract.ToString();
if (tmpSupplyResourceContract.GetType() == typeof(_HouseManagementService.exportSupplyResourceContractResultType))
{
var tmpExportSupplyResourceContract = tmpSupplyResourceContract as _HouseManagementService.exportSupplyResourceContractResultType;
if (tmpExportSupplyResourceContract.VersionStatus == _HouseManagementService.exportSupplyResourceContractResultTypeVersionStatus.Posted &&
tmpExportSupplyResourceContract.Item1.GetType() == typeof(_HouseManagementService.ExportSupplyResourceContractTypeOrganization))
{
Console.WriteLine("ContractRootGUID: {0}", tmpExportSupplyResourceContract.ContractRootGUID);
_ContractRootGUID = tmpExportSupplyResourceContract.ContractRootGUID;
_OrgRootEntityGUID = ((_HouseManagementService.ExportSupplyResourceContractTypeOrganization)tmpExportSupplyResourceContract.Item1).orgRootEntityGUID;
#region Экспорт информации о второй стороне договора
foreach (var itemOrgRegistry in helperOrganizationRegistryCommonService.GetOrgRegistry(_OrgRootEntityGUID).exportOrgRegistryResult.Items)
{
var ResultTypeOrgVersion = itemOrgRegistry as _OrganizationRegistryCommonService.exportOrgRegistryResultType;
var ItemLegalType = ResultTypeOrgVersion.OrgVersion.Item as _OrganizationRegistryCommonService.LegalType;
Console.WriteLine("Organization full name: {0}", ItemLegalType.FullName);
_OrgRootOrganizationINN = ItemLegalType.INN;
}
#endregion
#region Экспорт состояния оплаты
foreach (var tmpExportSettlements in helperBillService.GetSettlements(_orgPPAGUID, _ContractRootGUID).exportSettlementsResult.Items)
{
if (tmpExportSettlements.GetType() == typeof(_BillsService.ErrorMessageType) &&
((_BillsService.ErrorMessageType)tmpExportSettlements).ErrorCode != "INT002012")
{
var ErrorMessage = tmpExportSettlements as _BillsService.ErrorMessageType;
BaseClasses.OutputError(ErrorMessage.ErrorCode, ErrorMessage.Description);
}
else
{
if (tmpExportSettlements.GetType() != typeof(_BillsService.ErrorMessageType))
{
var resultExportSettlements = tmpExportSettlements as _BillsService.ExportSettlementResultType;
var reportingPeriodExportSettlements = resultExportSettlements.ReportingPeriod as _BillsService.ExportSettlementResultTypeReportingPeriod[];
isExistValue = reportingPeriodExportSettlements
.Any(obj => obj.ReportPeriodStatus.Status == _BillsService.ExportSettlementResultTypeReportingPeriodReportPeriodStatusStatus.Posted &&
obj.Month == DateTime.Now.AddMonths(-2).Month &&
obj.Year == DateTime.Now.AddMonths(-2).Year);
_SettlementGUID = resultExportSettlements.SettlementGUID;
_ContractRootGUID = null;
}
else
{
_SettlementGUID = null;
isExistValue = false;
}
if (isExistValue)
{
BaseClasses.OutputMessage(_OrgRootOrganizationINN + " Data for the period " + DateTime.Now.AddMonths(-2).Month + "." + DateTime.Now.AddMonths(-2).Year + " already exist");
}
else
{
#region Получение сведений о расчетах
string connectionString = @"Data Source=storage;Initial Catalog=master;User Id=" + ConfigurationManager.AppSettings["db_login"] + ";Password="******"db_pass"];
string sqlExpression = @"WITH t1
AS (
SELECT
CASE
WHEN [BAccount_ID] = 62.0
THEN d.[InvSum] + d.[InvVat]
ELSE 0
END AS TotalDebSum
,CASE
WHEN [BAccount_ID] = 62.5
THEN d.[InvSum] + d.[InvVat]
ELSE 0
END AS TotalAvansSum
,CASE
WHEN p.PayoffType = 0
THEN p.PayoffSum
ELSE 0
END AS TotalPayoffSum
FROM [VKAbon].[dbo].[Debit] d
LEFT JOIN [VKAbon].[dbo].[Abon_Details] ad ON d.Abon_ID = ad.Abon_ID
LEFT JOIN (
SELECT Debit_ID
,SUM(PayoffSum) AS PayoffSum
,PayoffType
FROM [VKAbon].[dbo].Payoff
GROUP BY Debit_ID
,PayoffType
) p ON d.Debit_ID = p.Debit_ID
WHERE ad.INN = @INN
AND YEAR(DebitDate) = @yearnumber
AND MONTH([DebitDate]) = @monthnumber
AND ad.DEnd = '2079-01-01'
)
SELECT
SUM(TotalDebSum) AS TotalDebSum
,SUM(TotalAvansSum) AS TotalAvansSum
,SUM(TotalPayoffSum) AS TotalPayoffSum
,SUM(TotalDebSum) - SUM(TotalPayoffSum) - SUM(TotalAvansSum) AS TotalSaldo
FROM t1
HAVING
SUM(TotalDebSum) IS NOT NULL
AND SUM(TotalAvansSum) IS NOT NULL
AND SUM(TotalPayoffSum) IS NOT NULL
AND SUM(TotalDebSum) - SUM(TotalPayoffSum) - SUM(TotalAvansSum) IS NOT NULL";
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand command = new SqlCommand(sqlExpression, connection);
SqlParameter _INN = new SqlParameter("@INN", _OrgRootOrganizationINN);
command.Parameters.Add(_INN);
SqlParameter _Month = new SqlParameter("@monthnumber", DateTime.Now.AddMonths(-2).Month);
command.Parameters.Add(_Month);
SqlParameter _Year = new SqlParameter("@yearnumber", DateTime.Now.AddMonths(-2).Year);
command.Parameters.Add(_Year);
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
_TotalDebSum = Convert.ToDecimal(reader["TotalDebSum"]);
_TotalAvansSum = Convert.ToDecimal(reader["TotalAvansSum"]);
_TotalPayoffSum = Convert.ToDecimal(reader["TotalPayoffSum"]);
_TotalSaldo = Convert.ToDecimal(reader["TotalSaldo"]);
}
#region Импорт состояния расчетов за период
foreach (var itemResultImportSettlement in helperBillService.SetRSOSettlements(_orgPPAGUID, _ContractRootGUID, _SettlementGUID, DateTime.Now.AddMonths(-2), _TotalDebSum, _TotalPayoffSum, _TotalSaldo, _TotalAvansSum).ImportResult.Items)
{
if (itemResultImportSettlement.GetType() == typeof(_BillsService.ErrorMessageType))
{
var ErrorMessage = itemResultImportSettlement as _BillsService.ErrorMessageType;
BaseClasses.OutputError(ErrorMessage.ErrorCode, ErrorMessage.Description);
}
else
{
var ResultType = itemResultImportSettlement as _BillsService.CommonResultType;
if (ResultType.Items[0].GetType() == typeof(_BillsService.CommonResultTypeError))
{
var ResultTypeError = ResultType.Items[0] as _BillsService.CommonResultTypeError;
BaseClasses.OutputError(ResultTypeError.ErrorCode, ResultTypeError.Description);
}
else
{
BaseClasses.OutputMessage(_OrgRootOrganizationINN + " Data import " + ResultType.Items[0]);
}
}
}
#endregion
}
else
{
BaseClasses.OutputMessage(_OrgRootOrganizationINN + " Settlements in our system is absent");
}
reader.Close();
connection.Close();
}
#endregion
}
}
}
#endregion
Console.WriteLine("-----------------------");
}
}
else
{
_ExportContractRootGUID = tmpSupplyResourceContract.ToString();
}
}
}while (typeRes != "True");
Console.Read();
}
static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
HelperHouseManagementService helperHouseManagementService = new HelperHouseManagementService();
HelperDeviceMeteringService helperDeviceMeteringService = new HelperDeviceMeteringService();
HelperNsiService helperNsiService = new HelperNsiService();
HelperBillService helperBillService = new HelperBillService();
ResidentalCalcDataClassesDataContext db = new ResidentalCalcDataClassesDataContext();
#region Синхронизируем справочник 51 Коммунальные услуги
Table <RefNsiService51> refNsiService51 = db.GetTable <RefNsiService51>();
var itemNsiReference51 = helperNsiService.GetNsiReference51(_orgPPAGUID).exportNsiItemResult;
var nsiElement = itemNsiReference51.Item as _NsiService.NsiItemType;
foreach (var itemNsiElement in nsiElement.NsiElement)
{
if (!(refNsiService51.Any(obj => obj.Code == itemNsiElement.Code &&
obj.GUID == Guid.Parse(itemNsiElement.GUID))))
{
db.spInsertRefNsiService51(itemNsiElement.Code,
Guid.Parse(itemNsiElement.GUID),
itemNsiElement.IsActual,
((_NsiService.NsiElementStringFieldType)itemNsiElement.NsiElementField[1]).Value);
Console.WriteLine("NsiService51 is synchronized");
}
else
{
foreach (var itemRef in refNsiService51.Where(s => s.GUID == Guid.Parse(itemNsiElement.GUID)))
{
if (itemRef.IsActual != itemNsiElement.IsActual)
{
itemRef.IsActual = itemNsiElement.IsActual;
db.SubmitChanges();
Console.WriteLine("Item is correct");
}
else
{
Console.WriteLine("NsiService51 already exist");
}
}
}
}
#endregion
#region Синхронизируем договоры
Table <SupplyResourceContract> supplyResourceContracts = db.GetTable <SupplyResourceContract>();
string typeRes = null;
do
{
foreach (var tmpSupplyResourceContract in helperHouseManagementService.GetSupplyResourceContractData(_orgPPAGUID, _ExportContractRootGUID).exportSupplyResourceContractResult.Items)
{
typeRes = tmpSupplyResourceContract.ToString();
if (tmpSupplyResourceContract.GetType() == typeof(_HouseManagementService.exportSupplyResourceContractResultType))
{
var tmpExportSupplyResourceContract = tmpSupplyResourceContract as _HouseManagementService.exportSupplyResourceContractResultType;
if (tmpExportSupplyResourceContract.VersionStatus == _HouseManagementService.exportSupplyResourceContractResultTypeVersionStatus.Posted &&
tmpExportSupplyResourceContract.Item1.GetType() == typeof(_HouseManagementService.ExportSupplyResourceContractTypeApartmentBuildingOwner))
{
if (!(supplyResourceContracts.Any(obj => obj.GIS_ContractRootGUID == Guid.Parse(tmpExportSupplyResourceContract.ContractRootGUID))))
{
db.spInsertSupplyResourceContract(((_HouseManagementService.ExportSupplyResourceContractTypeIsContract)tmpExportSupplyResourceContract.Item).ContractNumber,
((_HouseManagementService.ExportSupplyResourceContractTypeIsContract)tmpExportSupplyResourceContract.Item).SigningDate,
DateTime.Parse("2079-01-01"),
true,
Guid.Parse(tmpExportSupplyResourceContract.ContractRootGUID));
Console.WriteLine("Contract is synchronized");
}
else
{
Console.WriteLine("Contract already exist");
}
}
}
else
{
_ExportContractRootGUID = tmpSupplyResourceContract.ToString();
}
}
}while (typeRes != "True");
#endregion
#region Синхронизация предметов договора
Table <ContractSubject> contractSubject = db.GetTable <ContractSubject>();
foreach (var item in supplyResourceContracts.Where(s => s.GIS_ContractRootGUID != null))
{
foreach (var itemContract in helperHouseManagementService.GetSupplyResourceContractDataByContractRootGUID(_orgPPAGUID, item.GIS_ContractRootGUID.ToString()).exportSupplyResourceContractResult.Items)
{
if (itemContract.GetType() == typeof(_HouseManagementService.exportSupplyResourceContractResultType))
{
var tmpContract = itemContract as _HouseManagementService.exportSupplyResourceContractResultType;
var itemContractSubject = tmpContract.ContractSubject as _HouseManagementService.ExportSupplyResourceContractTypeContractSubject[];
foreach (var tmpContractSubject in itemContractSubject)
{
if (!(contractSubject.Any(obj => obj.SupplyResourceContractGUID == item.GUID &&
obj.ServiceGUID == Guid.Parse("2270143B-A8D6-44DE-882C-0E4EC953A011") ||
obj.ServiceGUID == Guid.Parse("09C92E62-A67C-46BA-9C7C-46FC6EC72A45"))))
{
db.spInsertContractSubject(tmpContractSubject.StartSupplyDate,
tmpContractSubject.EndSupplyDate,
Guid.Parse("2270143B-A8D6-44DE-882C-0E4EC953A011"),
item.GUID);
Console.WriteLine("Contract subject is synchronized");
}
else
{
Console.WriteLine("Contract subject already exist");
}
}
}
}
}
#endregion
#region Синхронизируем адресные объекты
Table <ObjectAddress> objectAddresses = db.GetTable <ObjectAddress>();
foreach (var item in supplyResourceContracts.Where(s => s.GIS_ContractRootGUID != null))
{
foreach (var itemObjectAddress in helperHouseManagementService.GetSupplyResourceContractObjectAddressData(_orgPPAGUID, item.GIS_ContractRootGUID.ToString()).exportSupplyResourceContractObjectAddressResult.Items)
{
if (itemObjectAddress.GetType() == typeof(_HouseManagementService.exportSupplyResourceContractObjectAddressResultType))
{
var tmpItemObjectAddress = itemObjectAddress as _HouseManagementService.exportSupplyResourceContractObjectAddressResultType;
if (!(objectAddresses.Any(obj => obj.GIS_ObjectGUID == Guid.Parse(tmpItemObjectAddress.ObjectGUID) &&
obj.SupplyResourceContractGUID == item.GUID)))
{
db.spInsertObjectAddress(Guid.Parse(item.GUID.ToString()),
Guid.Parse(tmpItemObjectAddress.FIASHouseGuid.ToString()),
tmpItemObjectAddress.ApartmentNumber,
tmpItemObjectAddress.RoomNumber,
Guid.Parse(tmpItemObjectAddress.ObjectGUID));
Console.WriteLine("Object address is synchronized");
}
else
{
Console.WriteLine("Object address already exist");
}
}
}
}
#endregion
#region Синхронизируем лицевые счета
Table <Accounts> accounts = db.GetTable <Accounts>();
foreach (var item in objectAddresses.Where(s => s.GIS_ObjectGUID != null))
{
foreach (var itemAccount in helperHouseManagementService.GetAccountDataByFiasGuid(_orgPPAGUID, item.FIASHouseGUID.ToString()).exportAccountResult.Items)
{
if (itemAccount.GetType() == typeof(_HouseManagementService.exportAccountResultType))
{
var tmpAccount = itemAccount as _HouseManagementService.exportAccountResultType;
if (!(accounts.Any(obj => obj.GIS_AccountGUID == Guid.Parse(tmpAccount.AccountGUID) &&
obj.ObjectAddressGUID == item.GUID)))
{
db.spInsertAccount(Guid.Parse(item.GUID.ToString()),
tmpAccount.AccountNumber,
true,
int.Parse(tmpAccount.LivingPersonsNumber ?? "2"),
Guid.Parse(tmpAccount.AccountGUID));
Console.WriteLine("Account is synchronized");
}
else
{
Console.WriteLine("Account already exist");
}
}
}
}
#endregion
#region Синхронизируем приборы учета
Table <MeteringDevice> meteringDevice = db.GetTable <MeteringDevice>();
foreach (var item in objectAddresses.Where(s => s.GIS_ObjectGUID != null))
{
foreach (var itemMeteringDevice in helperHouseManagementService.GetMeteringDeviceData(_orgPPAGUID, item.FIASHouseGUID.ToString()).exportMeteringDeviceDataResult.Items)
{
if (itemMeteringDevice.GetType() == typeof(_HouseManagementService.exportMeteringDeviceDataResultType))
{
var tmpMeterongDevice = itemMeteringDevice as _HouseManagementService.exportMeteringDeviceDataResultType;
if (!(meteringDevice.Any(obj => obj.GIS_MeteringDeviceGUID == Guid.Parse(tmpMeterongDevice.MeteringDeviceRootGUID) &&
obj.ObjectAddressGUID == item.GUID)))
{
db.spInsertMeteringDevice(Guid.Parse(item.GUID.ToString()),
tmpMeterongDevice.BasicChatacteristicts.MeteringDeviceModel,
tmpMeterongDevice.BasicChatacteristicts.MeteringDeviceStamp,
tmpMeterongDevice.BasicChatacteristicts.MeteringDeviceNumber,
6,
tmpMeterongDevice.BasicChatacteristicts.InstallationDate,
tmpMeterongDevice.BasicChatacteristicts.FirstVerificationDate,
Guid.Parse(tmpMeterongDevice.MeteringDeviceRootGUID));
Console.WriteLine("Metering device is synchronized");
}
else
{
Console.WriteLine("Metering device already exist");
}
}
}
}
#endregion
#region Синхронизируем показания приборов учета
Table <MeteringDeviceHistory> meteringDeviceHistory = db.GetTable <MeteringDeviceHistory>();
foreach (var item in meteringDevice.Where(s => s.GIS_MeteringDeviceGUID != null))
{
foreach (var itemMeteringDeviceHistory in helperDeviceMeteringService.GetMeteringDeviceHistory(_orgPPAGUID, item.ObjectAddress.FIASHouseGUID.ToString(), item.GIS_MeteringDeviceGUID.ToString()).exportMeteringDeviceHistoryResult.Items)
{
if (itemMeteringDeviceHistory.GetType() == typeof(_DeviceMeteringService.exportMeteringDeviceHistoryResultType))
{
var tmpMeteringDeviceHistory = itemMeteringDeviceHistory as _DeviceMeteringService.exportMeteringDeviceHistoryResultType;
var tmpMeteringDeviceHistoryDetail = tmpMeteringDeviceHistory.Item as _DeviceMeteringService.exportMeteringDeviceHistoryResultTypeOneRateDeviceValue;
foreach (var itemCurrentValue in tmpMeteringDeviceHistoryDetail.Values.CurrentValue)
{
var tmpCurrentValue = itemCurrentValue as _DeviceMeteringService.OneRateCurrentMeteringValueExportType;
if (!(meteringDeviceHistory.Any(obj => obj.MeteringDeviceDate == tmpCurrentValue.DateValue &&
obj.MeteringDeviceValue == Convert.ToDecimal(tmpCurrentValue.MeteringValue))))
{
db.spInsertMeteringDeviceHistory(item.GUID,
Convert.ToDecimal(tmpCurrentValue.MeteringValue),
tmpCurrentValue.DateValue);
Console.WriteLine("Metering device value is synchronized");
}
else
{
Console.WriteLine("Metering device value already exist");
}
}
}
}
}
#endregion
#region Синхронизация плательщиков
Table <PayerInfo> payerInfo = db.GetTable <PayerInfo>();
foreach (var item in accounts.Where(s => s.GIS_AccountGUID != null))
{
foreach (var itemAccount in helperHouseManagementService.GetAccountDataByAccontGuid(_orgPPAGUID, item.GIS_AccountGUID.ToString()).exportAccountResult.Items)
{
if (itemAccount.GetType() == typeof(_HouseManagementService.exportAccountResultType))
{
var tmpAccount = itemAccount as _HouseManagementService.exportAccountResultType;
if (!(payerInfo.Any(obj => obj.AccountGUID == item.GUID &&
obj.Name == ((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).FirstName &&
obj.Surname == ((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).Surname &&
obj.GrandName == ((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).Patronymic)))
{
var tmpAccountDetail = tmpAccount.PayerInfo as _HouseManagementService.AccountExportTypePayerInfo;
var tmp = tmpAccountDetail.Item as _HouseManagementService.AccountIndExportType;
db.spInsertPayerInfo(item.GUID,
((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).Surname,
((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).FirstName,
((_HouseManagementService.AccountIndExportType)tmpAccount.PayerInfo.Item).Patronymic ?? null,
"11111111111",
((_HouseManagementService.AccountIndExportTypeID)tmp.Item).Series ?? null,
((_HouseManagementService.AccountIndExportTypeID)tmp.Item).Number ?? null,
((_HouseManagementService.AccountIndExportTypeID)tmp.Item).IssueDate);
Console.WriteLine("Payer info is synchronized");
}
else
{
Console.WriteLine("Payer info already exist");
}
}
}
}
#endregion
Console.Read();
#region Создание расчетов
Table <Calculation> calculation = db.GetTable <Calculation>();
foreach (var itemAccount in accounts)
{
try
{
if (!(calculation.Any(obj => obj.AccountGUID == itemAccount.GUID &&
obj.CalculationMonth == DateTime.Now.Month &&
obj.CalculationYear == DateTime.Now.Year)))
{
db.spCreateCalculation(itemAccount.GUID, DateTime.Now.Month, DateTime.Now.Year);
Console.WriteLine("Calculation success");
}
else
{
Console.WriteLine("Calculation already exist");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
#endregion
#region Синхронизация квитанций
Table <vwChargeInfo> ChargeInfo = db.GetTable <vwChargeInfo>();
List <_BillsService.PaymentDocumentTypeChargeInfo> paymentDocumentTypeChargeInfos = new List <_BillsService.PaymentDocumentTypeChargeInfo>();
_BillsService.PDServiceChargeTypeMunicipalServiceVolumeDeterminingMethod _determiningMethod;
foreach (var itemCalculation in calculation.Where(s => s.GIS_PaymentDocumentNumber == null))
{
foreach (var itemChargeInfo in ChargeInfo.Where(s => s.CalculationGUID == itemCalculation.GUID))
{
if (itemChargeInfo.VolumeDeterminingMethodChar == "N")
{
_determiningMethod = _BillsService.PDServiceChargeTypeMunicipalServiceVolumeDeterminingMethod.N;
}
else
{
if (itemChargeInfo.VolumeDeterminingMethodChar == "O")
{
_determiningMethod = _BillsService.PDServiceChargeTypeMunicipalServiceVolumeDeterminingMethod.O;
}
else
{
_determiningMethod = _BillsService.PDServiceChargeTypeMunicipalServiceVolumeDeterminingMethod.M;
}
}
paymentDocumentTypeChargeInfos.Add(new _BillsService.PaymentDocumentTypeChargeInfo
{
Item = new _BillsService.PDServiceChargeTypeMunicipalService
{
AccountingPeriodTotal = (decimal)itemChargeInfo.CalculationResult, //Всего начислено за расчетный период
TotalPayable = (decimal)itemChargeInfo.CalculationResult, //Итого к оплате за расчетный период
Rate = contractSubject.Where(s => s.GUID == itemChargeInfo.ContractSubjectGUID).First().RefServices.RefTariff.TariffValue, //Тариф
ServiceType = new _BillsService.nsiRef
{
Code = contractSubject.First(s => s.GUID == itemChargeInfo.ContractSubjectGUID).RefServices.RefNsiService51.Code,
GUID = contractSubject.First(s => s.GUID == itemChargeInfo.ContractSubjectGUID).RefServices.RefNsiService51.GUID.ToString()
},
Consumption = new _BillsService.PDServiceChargeTypeMunicipalServiceVolume[]
{
new _BillsService.PDServiceChargeTypeMunicipalServiceVolume
{
typeSpecified = true,
type = _BillsService.PDServiceChargeTypeMunicipalServiceVolumeType.I, //(I)ndividualConsumption - индивидульное потребление (O)verallNeeds - общедомовые нужды
determiningMethodSpecified = true,
determiningMethod = _determiningMethod, //(N)orm - Норматив (M)etering device - Прибор учета (O)ther - Иное
Value = (decimal)itemChargeInfo.Volume
}
},
ServiceInformation = new _BillsService.ServiceInformation
{
individualConsumptionNormSpecified = true,
individualConsumptionNorm = contractSubject.First().RefServices.RefStandard.StandardValue //Норматив потребления в жилых помещениях
}
}
});
}
try
{
var test = helperBillService.SetPaymentDocumentData(_orgPPAGUID, itemCalculation.Accounts.GIS_AccountGUID.ToString(), paymentDocumentTypeChargeInfos).ImportResult.Items;
foreach (var itemTest in test)
{
if (itemTest.GetType() == typeof(_BillsService.CommonResultType))
{
var resTest = itemTest as _BillsService.CommonResultType;
foreach (var itemResTest in resTest.Items)
{
if (itemResTest.GetType() == typeof(_BillsService.CommonResultTypeError))
{
var resError = itemResTest as _BillsService.CommonResultTypeError;
Console.WriteLine("{0}: {1}", resError.ErrorCode, resError.Description);
}
else
{
itemCalculation.GIS_PaymentDocumentNumber = itemResTest.ToString();
db.SubmitChanges();
Console.WriteLine(itemResTest);
}
}
}
}
Console.WriteLine("Payment document is synchronized");
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
paymentDocumentTypeChargeInfos.Clear();
}
}
#endregion
Console.Read();
}
