Перем	ТаблицаДокументаНачисление;
Перем	ТаблицаКорреспонденцийДокументаОстатков;

//--------------------------------------------------------------------------------------------------

Перем	гСтрПуть;
Перем	гИмяФайла;

Перем	гСчетчикВыгруженныхОбъектов;

//Перем	СписокСписковВыгруженныхОбъектов;
Перем	ТабВыгруженныхОбъектов;

Перем	СписокУзловДобавляемыхПослеПроведения;

//Перем	гСписокОбработанныхПравил;
//Перем	гСписокНеобработанныхПравил;

Перем	ТабОбласть1;
Перем	ТабОбласть2;
Перем	ТабОбласть3;
Перем	ТабОбласть4;

Перем	гКонт;
Перем	гБезОткрытияФормы;

Перем	гСписокПараметров;

Перем	гXMLАнализатор;
Перем	гФайлДанных;
Перем	гПравила;

Перем	гПутьОбъекта_ИсполняемыйКод;

Перем	гТабОбъектов;	//	таблица интерактивно заданных объектов выгрузки

Перем	гТабКэшПравил;
Перем	гТабКэшРеквизитов;
Перем	гТабКэшРеквизитовЗначений;
Перем	гТабКэшПараметровЗагрузки;


////////////////////////////////////////////////////////////////////////////////////////////////////
//	Переменные переданные из интерфейсной формы

Перем	ФормДатаНач;
Перем	ФормДатаКон;
Перем	ФормИмяФайлаДанных;
                                                                    
Перем	ФормФлНеВыгружатьБухИтоги;
Перем	ФормДатаРасчетаБухИтогов;
Перем	ФормКодСчетаДляВводаОстатков;
Перем	ФормМаксКолвоПроводок;
Перем	ФормПланыСчетов;
Перем	ФормРазделителиУчета;

Перем	ФормКолвоБуферизуемыхОбъектов;
Перем	ФормФлВключатьПравилаВФайл;
Перем	ФормФлНеОбрабатыватьПроведение;
Перем	ФормФлВыгружатьТолькоИнтерактивные;

Перем	ФормФлЗапоминатьСсылки;


////////////////////////////////////////////////////////////////////////////////////////////////////
//	Переменные для свертки бух. итогов

Перем	гТекущийПланСчетов;
Перем	гТекущийРазделительУчета;
Перем	гТекущаяОперацияОстатков;
Перем	гТекущееКолвоПроводок;
Перем	гБухИтоги;
Перем	гКолвоОперацийСОстатками;


//**************************************************************************************************
//----	Начало предварительного описания функций	------------------------------------------------
//**************************************************************************************************

Функция	ДополнительныеПреобразования(Вид="", Ид="", Источник="", Приемник="", СписокПараметровПравила="")					Далее
Функция	Выгрузить(Источник, ИдПравила="", УзелСсылки=0, ПараметрыПравила="", Знач ТипПриемника="", Знач ВидПриемника="")	Далее
Функция	ПроверитьГруппуУсловий(Знач Условия, Знач Объект, Знач ТипУсловия="И")												Далее
Функция	УсловияВыполняются(Знач Условия, Знач Объект, ИдПравилаДок="")														Далее
Функция	ПолучитьИдОбъектаИсточника(Источник, ИдСинхронизирующегоРеквизита="")												Далее
Функция ПолучитьЗначениеМетодом(Источник, Метод)																			Далее
Функция ДобавитьРеквизит(Таб, Источник, Приемник="", Знач Зн="#Получить", Знач СпособЗагрузкиПоУмолчанию="", СписокДопПараметровПравила="")	Далее

Процедура ЗаписатьОперациюБухИтогов(Док)	Далее
Процедура НачальнаяИнициализация()			Далее

//**************************************************************************************************
//----	Конец предварительного описания функций	----------------------------------------------------
//**************************************************************************************************
               


//**************************************************************************************************
//----	Начало процедур и функций свертки бух. итогов
//**************************************************************************************************

Функция ДобавитьПроводку(Счет, СписокСубконто, Валюта, Сумма, ВалСумма, Количество)
	
	// если все остатки равны нулю то не делать проводку
	Если (Сумма = 0) И (ВалСумма = 0) И (Количество = 0) Тогда
	    Возврат 1;
	КонецЕсли;    
	
	гТекущаяОперацияОстатков.НоваяПроводка();
	// выбор корреспонденции счета
	Если Счет.Активный = 1 Тогда
		ОсновнаяКорреспонденция = гТекущаяОперацияОстатков.Дебет;
		ВспомКорреспонденция = гТекущаяОперацияОстатков.Кредит;
		Знак = 1;
    ИначеЕсли Счет.Активный = 2 Тогда
		ОсновнаяКорреспонденция = гТекущаяОперацияОстатков.Кредит;
		ВспомКорреспонденция = гТекущаяОперацияОстатков.Дебет;
		Знак = -1;
	ИначеЕсли (Сумма < 0) Или ((Сумма = 0) И (ВалСумма < 0)) Или 
			  ((Сумма = 0) И (ВалСумма = 0) И (Количество < 0)) Тогда
		ОсновнаяКорреспонденция = гТекущаяОперацияОстатков.Кредит;
		ВспомКорреспонденция = гТекущаяОперацияОстатков.Дебет;
		Знак = -1;
	Иначе
		ОсновнаяКорреспонденция = гТекущаяОперацияОстатков.Дебет;
		ВспомКорреспонденция = гТекущаяОперацияОстатков.Кредит;
		Знак = 1;
	КонецЕсли;
	                                     
	ОсновнаяКорреспонденция.Счет = Счет.ТекущийСчет();
	Если ПустоеЗначение(СписокСубконто) = 0 Тогда
		Для Инд=1 По СписокСубконто.РазмерСписка() Цикл
			ВидСубконто = Счет.ВидСубконто(СписокСубконто.ПолучитьЗначение(Инд));
			ОсновнаяКорреспонденция.Субконто(ВидСубконто, гБухИтоги.Субконто(ВидСубконто));
		КонецЦикла;                                           
	КонецЕсли;

	Если Счет.Забалансовый = 0 Тогда
	    ВспомКорреспонденция.Счет = СчетПоКоду(ФормКодСчетаДляВводаОстатков, гТекущийПланСчетов);
	КонецЕсли;
	
	Если Счет.Валютный = 1 Тогда
		гТекущаяОперацияОстатков.Валюта = Валюта;  
	КонецЕсли;
	
	Если Метаданные.РазделительУчета.Выбран() = 1 Тогда
		гТекущаяОперацияОстатков.УстановитьАтрибут(Метаданные.РазделительУчета.Идентификатор, гБухИтоги.ИспользоватьРазделительУчета());
	КонецЕсли;
	
	гТекущаяОперацияОстатков.Сумма		=	Знак * Сумма;
	гТекущаяОперацияОстатков.ВалСумма	=	Знак * ВалСумма;
	гТекущаяОперацияОстатков.Количество	=	Знак * Количество;
	
	гТекущееКолвоПроводок = гТекущееКолвоПроводок + 1;
	Если гТекущееКолвоПроводок = ФормМаксКолвоПроводок Тогда
		
		гТекущаяОперацияОстатков.ДатаОперации	=	ФормДатаКон;
		гТекущаяОперацияОстатков.Содержание		=	"#Остатки по счетам (" + гКолвоОперацийСОстатками + ")";
		
		ЗаписатьОперациюБухИтогов(гТекущаяОперацияОстатков.Документ);
		
		гКолвоОперацийСОстатками	=	гКолвоОперацийСОстатками + 1;
		
		гТекущаяОперацияОстатков.Новая();
		гТекущееКолвоПроводок = 0;
		
	КонецЕсли;
	
	Возврат 1;
	
КонецФункции		//	ДобавитьПроводку()

//--------------------------------------------------------------------------------------------------

Функция СформироватьОстаткиПоСубконто(НомерСубконто, Счет, СписокСубконто, Валюта, Сумма, ВалСумма, Количество, ПоСумме, ПоВалСумме, ПоКоличеству)
	
	Если НомерСубконто > СписокСубконто.РазмерСписка() Тогда
        ДобавитьПроводку(Счет, СписокСубконто, Валюта, Сумма, ВалСумма, Количество);
		Сумма = 0;
		ВалСумма = 0;
		Количество = 0;
	Иначе                  
		ПозицияСубконто = СписокСубконто.ПолучитьЗначение(НомерСубконто);
		ВидСубконто = Счет.ВидСубконто(ПозицияСубконто);
		гБухИтоги.ВыбратьСубконто(ВидСубконто);
		Пока гБухИтоги.ПолучитьСубконто(ВидСубконто) = 1 Цикл
			Если (Счет.УчетПоСумме(ПозицияСубконто) = 1) И (ПоСумме = 1) Тогда
				Сумма = гБухИтоги.СКД()-гБухИтоги.СКК();
			КонецЕсли;
			Если (Счет.УчетПоВалютнойСумме(ПозицияСубконто) = 1) И (ПоВалСумме = 1) Тогда
				ВалСумма = гБухИтоги.СКД(2)-гБухИтоги.СКК(2);
			КонецЕсли;
			Если (Счет.УчетПоКоличеству(ПозицияСубконто) = 1) И (ПоКоличеству = 1) Тогда
				Количество = гБухИтоги.СКД(3)-гБухИтоги.СКК(3);
			КонецЕсли;
		    СформироватьОстаткиПоСубконто(НомерСубконто+1, Счет, СписокСубконто, Валюта, Сумма, ВалСумма, Количество, ПоСумме, ПоВалСумме, ПоКоличеству);
		КонецЦикла;
	КонецЕсли;
	
	Возврат 1;
	
КонецФункции		//	СформироватьОстаткиПоСубконто()

//--------------------------------------------------------------------------------------------------

Функция СформироватьОстаткиПоВалюте(Счет, СписокСубконто, ПоСумме, ПоВалСумме, ПоКоличеству)
	
	Сумма = 0;
	ВалСумма = 0;
	Количество = 0;
	Если Счет.Валютный = 1 Тогда
	    гБухИтоги.ВыбратьВалюты();
		Пока гБухИтоги.ПолучитьВалюту() = 1 Цикл
			Если ПоСумме = 1 Тогда
				Сумма = гБухИтоги.СКД()-гБухИтоги.СКК();
			КонецЕсли;
			Если ПоВалСумме = 1 Тогда
				ВалСумма = гБухИтоги.СКД(2)-гБухИтоги.СКК(2);
			КонецЕсли;
			Если ПоКоличеству = 1 Тогда
				Количество = гБухИтоги.СКД(3)-гБухИтоги.СКК(3);
			КонецЕсли;
		    Если СформироватьОстаткиПоСубконто(1, Счет, СписокСубконто, гБухИтоги.Валюта, Сумма, ВалСумма, Количество, ПоСумме, ПоВалСумме, ПоКоличеству) = 0 Тогда
				Возврат 0;
			КонецЕсли;
		КонецЦикла;
	Иначе
		Если ПоСумме = 1 Тогда
			Сумма = гБухИтоги.СКД()-гБухИтоги.СКК();
		КонецЕсли;
		Если ПоВалСумме = 1 Тогда
			ВалСумма = гБухИтоги.СКД(2)-гБухИтоги.СКК(2);
		КонецЕсли;
		Если ПоКоличеству = 1 Тогда
			Количество = гБухИтоги.СКД(3)-гБухИтоги.СКК(3);
		КонецЕсли;
	    Если СформироватьОстаткиПоСубконто(1, Счет, СписокСубконто, 0, Сумма, ВалСумма, Количество, ПоСумме, ПоВалСумме, ПоКоличеству) = 0 Тогда
			Возврат 0;
		КонецЕсли;
	КонецЕсли;
	Возврат 1;
	
КонецФункции //СформироватьОстаткиПоВалюте()

//--------------------------------------------------------------------------------------------------

Функция СформироватьОстаткиПоСчету(Счет, РазделительУчета)
	
	Перем Стр;
	
    Сообщение = "Формирование остатков ";

	// список позиций в счете видов субконто
	СписокСубконто = СоздатьОбъект("СписокЗначений"); 
	
	Если Метаданные.РазделительУчета.Выбран() = 1 Тогда   
		Сообщение = Сообщение + ":  " + РазделительУчета;
		гБухИтоги.ИспользоватьРазделительУчета(РазделительУчета);    
	КонецЕсли;                                                        
	
	Если ПланыСчетов.КоличествоЗначений() > 1 Тогда
		Сообщение = Сообщение + "  план: " + Счет.ПланСчетов();
	КонецЕсли;
	Сообщение = Сообщение + " по счету: " + Счет;

	// Флаг показывающий что настройки субконто позволяют 
	// сформировать все проводки за 1 проход
	ПоВсем = 1;
	// добавляем группировки по видам субконто              
	Для Инд = 1 По Счет.КоличествоСубконто() Цикл
		// оборотные субконто пропускаем так как по ним нет остатков
		Если Счет.ТолькоОбороты(Инд) = 1 Тогда
			Продолжить;
		КонецЕсли;
		А1 = 0;
		А2 = 0;
		гБухИтоги.ИспользоватьСубконто(Счет.ВидСубконто(Инд));
		// для последующего анализа на предмет возможности 
		// сформировать все проводки за 1 проход
		Если Счет.УчетПоСумме(Инд) = 1 Тогда
			А1 = А1+1;
			А2 = А2+1;
		КонецЕсли;
		Если (Счет.Валютный = 1) И (Счет.УчетПоВалютнойСумме(Инд) = 1) Тогда
			А1 = А1+1;
			А2 = А2+2;
		КонецЕсли;
		Если (Счет.Количественный = 1) И (Счет.УчетПоКоличеству(Инд) = 1) Тогда
			А1 = А1+1;
			А2 = А2+4;
		КонецЕсли;
		СписокСубконто.ДобавитьЗначение(Инд, ""+А1+А2+Инд);
	КонецЦикла;
	СписокСубконто.СортироватьПоПредставлению(1);         

	// анализ возможности сформировать все проводки за 1 проход
	А1 = 0;
	А2 = 0;
	Для Инд=1 По СписокСубконто.РазмерСписка() Цикл
		СписокСубконто.ПолучитьЗначение(Инд, Стр);
		А11 = Число(Сред(Стр, 1, 1));
		А22 = Число(Сред(Стр, 2, 1));
		Если А1 = А11 Тогда
			Если А2 <> А22 Тогда
			  ПоВсем = 0;
			  Прервать;
			КонецЕсли;
		ИначеЕсли (А1 <> 3) И (А11 <> 3) Тогда
			Если 7-А2 = А22 Тогда
			  ПоВсем = 0;
			  Прервать;
			КонецЕсли;
		КонецЕсли;
		А1 = А11;
		А2 = А22;
	КонецЦикла;
	        
	// выборка итогов по счету
	ВидСуммы = "С";
	Если Счет.Валютный = 1 Тогда
	    ВидСуммы = ВидСуммы+"В";
	КонецЕсли;
	Если Счет.Количественный = 1 Тогда
	    ВидСуммы = ВидСуммы+"К";
	КонецЕсли;                
	
	Если гБухИтоги.ВыполнитьЗапрос(, ФормДатаРасчетаБухИтогов, Счет,,, 1,, ВидСуммы) = 0 Тогда
		Возврат 0;
	КонецЕсли;
	
	Состояние(Сообщение);
	                          
	Если ПоВсем = 1 Тогда
		// формирование за один проход 
		Если СформироватьОстаткиПоВалюте(Счет, СписокСубконто, 1, 1, 1) = 0 Тогда
			Возврат 0;
		КонецЕсли;
	Иначе                                      
		// формирование за несколько проходов 
		СписокСубконто.УдалитьВсе();
		Для Инд=1 По Счет.КоличествоСубконто() Цикл
			Если (Счет.ТолькоОбороты(Инд) = 0) И (Счет.УчетПоСумме(Инд) =  1) Тогда
			    СписокСубконто.ДобавитьЗначение(Инд);
			КонецЕсли;                               
		КонецЦикла;
		Если СформироватьОстаткиПоВалюте(Счет, СписокСубконто, 1, 0, 0) = 0 Тогда
			Возврат 0;
		КонецЕсли;
                                                             
		Если Счет.Валютный = 1 Тогда
			СписокСубконто.УдалитьВсе();
			Для Инд=1 По Счет.КоличествоСубконто() Цикл
				Если (Счет.ТолькоОбороты(Инд) = 0) И (Счет.УчетПоВалютнойСумме(Инд) =  1) Тогда
				    СписокСубконто.ДобавитьЗначение(Инд);
				КонецЕсли;                               
			КонецЦикла;
			Если СформироватьОстаткиПоВалюте(Счет, СписокСубконто, 0, 1, 0) = 0 Тогда
				Возврат 0;
			КонецЕсли;
		КонецЕсли;              
		
		Если Счет.Количественный = 1 Тогда
			СписокСубконто.УдалитьВсе();
			Для Инд=1 По Счет.КоличествоСубконто() Цикл
				Если (Счет.ТолькоОбороты(Инд) = 0) И (Счет.УчетПоКоличеству(Инд) =  1) Тогда
				    СписокСубконто.ДобавитьЗначение(Инд);
				КонецЕсли;                               
			КонецЦикла;
			Если СформироватьОстаткиПоВалюте(Счет, СписокСубконто, 0, 0, 1) = 0 Тогда
				Возврат 0;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
	Возврат 1;
	
КонецФункции		//	СформироватьОстаткиПоСчету()

//--------------------------------------------------------------------------------------------------

Функция СформироватьОстаткиПоСчетам(ПланСчетов, РазделительУчета)
	
    //СодержаниеОперации = "#Остатки по счетам";
	//Если Метаданные.РазделительУчета.Выбран() = 1 Тогда   
	//    СодержаниеОперации = СодержаниеОперации + " разделитель учета: " + РазделительУчета +  "  ";
	//КонецЕсли;
	//Если ПланыСчетов.КоличествоЗначений() > 1 Тогда
	//    СодержаниеОперации = СодержаниеОперации + "план счетов: " + ПланСчетов + "  ";
	//КонецЕсли;                                  
	
	СписокВыбранныхСчетов	=	ФормПланыСчетов.Получить(гТекущийПланСчетов.Идентификатор());
	
	
	Счет = СоздатьОбъект("Счет." + ПланСчетов.Идентификатор());
	Счет.ВыбратьСчета();
	Пока Счет.ПолучитьСчет() = 1 Цикл
		
		Если СписокВыбранныхСчетов.Принадлежит(Счет.ТекущийСчет()) = 0 Тогда Продолжить КонецЕсли;
		
		Если Счет.Уровень() = 1 Тогда
			Если гТекущееКолвоПроводок > ФормМаксКолвоПроводок Тогда
				
				гТекущаяОперацияОстатков.ДатаОперации	=	ФормДатаКон;
				гТекущаяОперацияОстатков.Содержание		=	"#Остатки по счетам (" + гКолвоОперацийСОстатками + ")";
				
				ЗаписатьОперациюБухИтогов(гТекущаяОперацияОстатков.Документ);
				
				гКолвоОперацийСОстатками	=	гКолвоОперацийСОстатками + 1;
				
				гТекущаяОперацияОстатков.Новая();
				гТекущееКолвоПроводок = 0;
				
			КонецЕсли;
		КонецЕсли;
		
		Если Счет.ЭтоГруппа() = 1 Тогда Продолжить КонецЕсли;
		
	    Если СформироватьОстаткиПоСчету(Счет, РазделительУчета) = 0 Тогда Возврат(0) КонецЕсли;
		
	КонецЦикла;   
	
	Если гТекущееКолвоПроводок > 0 Тогда
		
		гТекущаяОперацияОстатков.ДатаОперации	=	ФормДатаКон;
		гТекущаяОперацияОстатков.Содержание		=	"#Остатки по счетам (" + гКолвоОперацийСОстатками + ")";
		
		ЗаписатьОперациюБухИтогов(гТекущаяОперацияОстатков.Документ);
		
		гКолвоОперацийСОстатками	=	гКолвоОперацийСОстатками + 1;
		
		гТекущаяОперацияОстатков.Новая();
		гТекущееКолвоПроводок = 0;
		
	КонецЕсли;
	
	//Если Метаданные.РазделительУчета.Выбран() = 1 Тогда   
	//	Сообщить("Сформированы остатки по счетам по разделителю учета:  """+СокрЛП(РазделительУчета)+"""");
	//Иначе
	//	Сообщить("Сформированы остатки по счетам.");
	//КонецЕсли;
	
	Возврат(1);
	
КонецФункции		//	СформироватьОстаткиПоСчетам()

//--------------------------------------------------------------------------------------------------

Функция СформироватьОстаткиПоРазделителямУчета()
		 
	Если ФормРазделителиУчета.ПолучитьЗначение(1) = "<Не используется>" Тогда
		гТекущийРазделительУчета = ПолучитьПустоеЗначение();
		Возврат	СформироватьОстаткиПоСчетам(гТекущийПланСчетов, гТекущийРазделительУчета);
	КонецЕсли;
	
	Для Сч = 1 По ФормРазделителиУчета.РазмерСписка() Цикл
		Если ФормРазделителиУчета.Пометка(Сч)=0 Тогда Продолжить КонецЕсли;
		гТекущийРазделительУчета	=	ФормРазделителиУчета.ПолучитьЗначение(Сч);
		Если СформироватьОстаткиПоСчетам(гТекущийПланСчетов, гТекущийРазделительУчета) = 0 Тогда Возврат(0) КонецЕсли;
	КонецЦикла;
	
	Возврат 1;
		
КонецФункции		//	СформироватьОстаткиПоРазделителямУчета()

//--------------------------------------------------------------------------------------------------

Процедура ЗакрытиеСчетов()
	
	Для Сч = 1 По ФормПланыСчетов.РазмерСписка() Цикл
		Если ФормПланыСчетов.Пометка(Сч)=0 Тогда Продолжить КонецЕсли;
		гТекущаяОперацияОстатков = СоздатьОбъект("Операция");
		гТекущаяОперацияОстатков.Новая();
		гТекущееКолвоПроводок	= 0;
		
		//гТекущийПланСчетов	=	ФормПланыСчетов.ПолучитьЗначение(Сч);
		
		гТекущийПланСчетов		=	ПланыСчетов.ЗначениеПоНомеру(Сч);
		
		Если СформироватьОстаткиПоРазделителямУчета() = 0 Тогда Возврат КонецЕсли;
	КонецЦикла;
	
КонецПроцедуры		//	ЗакрытиеСчетов()


//**************************************************************************************************
//----	Конец процедур и функций свертки бух. итогов
//**************************************************************************************************


//--------------------------------------------------------------------------------------------------
                                                                                                    
Процедура УстановитьАтрибут(Элемент, ИдАтрибута, ЗнАтрибута, Проверить=1);
	
	Если	Проверить = 1 Тогда
		Если ПустоеЗначение(ЗнАтрибута) = 0 Тогда
			ЗнАтрибута	=	СтрЗаменить(ЗнАтрибута,	РазделительСтрок,	"#рс#" );
			ЗнАтрибута	=	СтрЗаменить(ЗнАтрибута,	СимволТабуляции,	"#ст#" );
			Элемент.УстановитьАтрибут(ИдАтрибута, ЗнАтрибута);
		КонецЕсли;
	Иначе
		ЗнАтрибута	=	СтрЗаменить(ЗнАтрибута,	РазделительСтрок,	"#рс#" );
		ЗнАтрибута	=	СтрЗаменить(ЗнАтрибута,	СимволТабуляции,	"#ст#" );
		Элемент.УстановитьАтрибут(ИдАтрибута, ЗнАтрибута);
	КонецЕсли;
	
КонецПроцедуры		//	УстановитьАтрибут()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция КопироватьУзел(Узел)
	
	Если ПустоеЗначение(Узел) = 1 Тогда Возврат("") КонецЕсли;
	
	XML_DOM		=	гXMLАнализатор.СоздатьДокумент();
	XML_DOM.ЗагрузитьИзСтроки(Узел.ПредставлениеXML);
	КопияУзла	=	XML_DOM.ВыбратьУзел(Узел.ИмяТэга);
	
	Возврат( КопияУзла );
	
КонецФункции		//	КопироватьУзел()

//--------------------------------------------------------------------------------------------------

Процедура ЗаписатьОшибку(Содержание, Маркер="")
                        
	Сообщить(Содержание, Маркер);
	
КонецПроцедуры		//	ЗаписатьОшибку()

//--------------------------------------------------------------------------------------------------

Функция ОтделитьРазделителем(Стр, Знач Разделитель, Режим=0)

	ПраваяЧасть	=	"";
	Разделитель	=	Найти(Стр, Разделитель);
	Если Разделитель > 0 Тогда
		ПраваяЧасть	=	Сред(Стр,		Разделитель + ?(Режим=2, 0, 1));
		Стр			=	СокрЛП(Лев(Стр,	Разделитель - ?(Режим=1, 0, 1)));
	КонецЕсли;

	Возврат(ПраваяЧасть);
	
КонецФункции		//	ОтделитьРазделителем()




//**************************************************************************************************
//----	Начало функций	проверки условий	--------------------------------------------------------
//**************************************************************************************************

Функция ПривестиКТипу(Зн, Тип)
	
    Если		Тип = "Дата"	Тогда
		Возврат	Дата(Зн);                                  
	ИначеЕсли	Тип = "Число"	Тогда
		Возврат	Число(Зн);
	Иначе
		Возврат	НРег(СокрЛП(Зн));
	КонецЕсли;
	
КонецФункции

//--------------------------------------------------------------------------------------------------

Функция ПроверитьУсловие(Знач Условие, Знач Объект)
	
	ИдРеквизита			=	Условие.ПолучитьАтрибут("Реквизит");
	ВидУсловия			=	Условие.ПолучитьАтрибут("ВидУсловия");
	РеквизитОперации	=	Условие.ПолучитьАтрибут("ЭтоРеквизитОперации");
	Если Найти(ИдРеквизита, "()") > 0 Тогда
		Значение		=	ПолучитьЗначениеМетодом(Объект, ИдРеквизита);
	Иначе    
		Если		ПустоеЗначение(ИдРеквизита) = 1			Тогда
			Значение	=	Объект;
		//ИначеЕсли	ПустоеЗначение(СокрЛП(Объект)) = 1		Тогда
		//	Возврат(0);	
		ИначеЕсли	ТипЗначенияСтр(Объект) = "Операция"		Тогда
			Если		ИдРеквизита = "СчетДт" Тогда
				Значение	=	Объект.Дебет.Счет;
			ИначеЕсли	ИдРеквизита = "СчетКт" Тогда
				Значение	=	Объект.Кредит.Счет;
			Иначе
				Значение	=	Объект.ПолучитьАтрибут(ИдРеквизита);
			КонецЕсли;
		ИначеЕсли	ПустоеЗначение(РеквизитОперации) = 1	Тогда
			Значение		=	Объект.ПолучитьАтрибут(ИдРеквизита);
		Иначе
			Значение		=	Объект.Операция.ПолучитьАтрибут(ИдРеквизита);
		КонецЕсли;
	КонецЕсли;
	
	Если		ВидУсловия	=	"УдовлетворяетУсловию" Тогда
		
		Возврат	УсловияВыполняются(Условие.ВыбратьУзел("Условия"), Значение);
		
	Иначе
		ТипЗнач		=	ТипЗначенияСтр(Значение);
		
		Зн			=	ПривестиКТипу(ПолучитьИдОбъектаИсточника(Значение), ТипЗнач);
		
		Знач1		=	ПривестиКТипу(Условие.ПолучитьАтрибут("Знач1"), 	ТипЗнач);
		Знач2		=	ПривестиКТипу(Условие.ПолучитьАтрибут("Знач2"), 	ТипЗнач);
		
		Если		ВидУсловия	=	"Равно"					Тогда	Возврат ?(	Зн	=	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"НеРавно"				Тогда	Возврат ?(	Зн	<>	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"ПустоеЗначение"		Тогда	Возврат ?(	ПустоеЗначение(Зн) = 1			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"НеПустоеЗначение"		Тогда	Возврат ?(	ПустоеЗначение(Зн) = 0			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"ВключаетПодстроку"		Тогда	Возврат ?(	Найти(Зн, Знач1) > 0			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"НеВключаетПодстроку"	Тогда	Возврат	?(	Найти(Зн, Знач1) = 0			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"ЯвляетсяПодстрокой"	Тогда	Возврат ?(	Найти(Знач1, Зн) > 0			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"НеЯвляетсяПодстрокой"	Тогда	Возврат	?(	Найти(Знач1, Зн) = 0			, 1, 0);
		ИначеЕсли	ВидУсловия	=	"Больше"				Тогда	Возврат ?(	Зн	>	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"БольшеИлиРавно"		Тогда	Возврат ?(	Зн	>=	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"Меньше"				Тогда	Возврат ?(	Зн	<	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"МеньшеИлиРавно"		Тогда	Возврат	?(	Зн	<=	Знач1					, 1, 0);
		ИначеЕсли	ВидУсловия	=	"ИнтервалСГраницами"	Тогда	Возврат ?(	(Зн	>=	Знач1) И (Зн <=	Знач2)	, 1, 0);
		ИначеЕсли	ВидУсловия	=	"ИнтервалБезГраниц"		Тогда	Возврат ?(	(Зн	>	Знач1) И (Зн <	Знач2)	, 1, 0);
		Иначе		ЗаписатьОшибку("Не идентифицирован вид условия:   " + ВидУсловия);
		КонецЕсли;
	КонецЕсли;
	
КонецФункции		//	ПроверитьУсловие()

//--------------------------------------------------------------------------------------------------

Функция ПроверитьГруппуУсловий(Знач Условия, Знач Объект, Знач ТипУсловия="И")
	
	Если ПустоеЗначение(Условия)	= 1				Тогда	Возврат(1)								КонецЕсли;
	Если ПустоеЗначение(ТипУсловия) = 1				Тогда	ТипУсловия = "И"						КонецЕсли;
	
	Если ТипЗначенияСтр(Объект)		= "Справочник"	Тогда	Объект.ИспользоватьДату(ФормДатаКон, 1)	КонецЕсли;
	                                                                     
	ВыборкаУсловий	=	Условия.ВыбратьУзлы("Условие");
	Для СчУсловий = 0 По ВыборкаУсловий.КоличествоУзлов() - 1 Цикл
		Условие		=	ВыборкаУсловий.ПолучитьУзел(СчУсловий);
		Результат	=	ПроверитьУсловие(Условие, Объект);
		Если		(ТипУсловия = "И")		И	(Результат=0)	Тогда	Возврат(0);
		ИначеЕсли	(ТипУсловия = "Или")	И	(Результат=1)	Тогда	Возврат(1);
		ИначеЕсли	(ТипУсловия = "Не")		И	(1-Результат=1)	Тогда	Возврат(1);
		КонецЕсли;
	КонецЦикла;
	
	ВыборкаГрупп	=	Условия.ВыбратьУзлы("ГруппаУсловий");
	Для СчГрупп = 0 По ВыборкаГрупп.КоличествоУзлов() - 1 Цикл
		ГруппаУсловий	=	ВыборкаГрупп.ПолучитьУзел(СчГрупп);
		ТипУсл			=	ГруппаУсловий.ПолучитьАтрибут("ТипУсловия");
		Результат		=	ПроверитьГруппуУсловий(ГруппаУсловий, Объект, ТипУсл);
		Если		(ТипУсловия = "И")		И	(Результат=0)	Тогда	Возврат(0);
		ИначеЕсли	(ТипУсловия = "Или")	И	(Результат=1)	Тогда	Возврат(1);
		ИначеЕсли	(ТипУсловия = "Не")		И	(1-Результат=1)	Тогда	Возврат(1);
		КонецЕсли;
	КонецЦикла;
	
	Если		ТипУсловия = "И"	Тогда	Возврат(1);
	ИначеЕсли	ТипУсловия = "Или"	Тогда	Возврат(0);
	ИначеЕсли	ТипУсловия = "Не"	Тогда	Возврат(0);
	КонецЕсли;
	
КонецФункции

//--------------------------------------------------------------------------------------------------

Функция УсловияВыполняются(Знач Условия, Знач Объект, ИдПравилаДок="")
	
	Если ПустоеЗначение(Условия.ПолучитьАтрибут("ЕстьПроцедура")) = 0 Тогда
		Возврат ДополнительныеПреобразования("Условие", Условия.ПолучитьАтрибут("Ид"), Объект, , ИдПравилаДок);
	КонецЕсли;
	
	Если ПроверитьГруппуУсловий(Условия, Объект) = 0 Тогда Возврат(0) КонецЕсли;	//	проверка одиночных условий
	
	ВыборкаГрупп	=	Условия.ВыбратьУзлы("ГруппаУсловий");
	Для СчГрупп = 0 По ВыборкаГрупп.КоличествоУзлов() - 1 Цикл
		ГруппаУсловий	=	ВыборкаГрупп.ПолучитьУзел(СчГрупп);
		ТипУсловия		=	ГруппаУсловий.ПолучитьАтрибут("ТипУсловия");
		Если ПроверитьГруппуУсловий(ГруппаУсловий, Объект, ТипУсловия) = 0 Тогда Возврат(0) КонецЕсли;
	КонецЦикла;
	
	Возврат(1);
	
КонецФункции

//**************************************************************************************************
//----	Конец функций	проверки условий	--------------------------------------------------------
//**************************************************************************************************


//--------------------------------------------------------------------------------------------------

Процедура ЗагрузитьПараметрыЗагрузки(Правило, Ид="")
                                     
	Если		(ПустоеЗначение(Ид) = 1)	И (ПустоеЗначение(Правило) = 0)	Тогда
		Ид		=	Правило.ПолучитьАтрибут("ПараметрыЗагрузки");
	КонецЕсли;
	Если	ПустоеЗначение(Ид) = 1		Тогда
		гТабКэшПараметровЗагрузки.ПолучитьСтрокуПоНомеру(1);	//	в первой строке описаны параметры по умолчанию
		Возврат;
	КонецЕсли;
	
	НомСтр	=	"";
	
	Если  гТабКэшПараметровЗагрузки.НайтиЗначение(Ид, НомСтр, "Ид") = 0 Тогда

		ПараметрыЗагрузки	=	гПравила.ВыбратьУзел("//ПараметрыЗагрузки[@Ид=""" + СокрЛП(Ид) + """]");
		
		Если ПустоеЗначение(ПараметрыЗагрузки) = 1 Тогда
			ЗаписатьОшибку("Не найдены параметры загрузки. Ид = " + Ид + "!", "!!");
			гТабКэшПараметровЗагрузки.ПолучитьСтрокуПоНомеру(1);
			Возврат;
		КонецЕсли;
		
		гТабКэшПараметровЗагрузки.НоваяСтрока();
		гТабКэшПараметровЗагрузки.Ид							=	Ид;
	    
		ДатаУстановки											=	Дата(ПараметрыЗагрузки.ПолучитьАтрибут("Дата"));
		гТабКэшПараметровЗагрузки.Дата							=	?(ПустоеЗначение(ДатаУстановки)=1, ФормДатаКон, ДатаУстановки);

		СпособЗагрузки											=	ПараметрыЗагрузки.ПолучитьАтрибут("СпособЗагрузки");
		гТабКэшПараметровЗагрузки.СпособЗагрузки				=	?(ПустоеЗначение(СпособЗагрузки)=1, "ЗамещатьНеПустыми", СпособЗагрузки);
		
		гТабКэшПараметровЗагрузки.ПравилоОпераций				=	ПараметрыЗагрузки.ПолучитьАтрибут("ПравилоОпераций");
		
		гТабКэшПараметровЗагрузки.СтатусУдаления				=	ПараметрыЗагрузки.ПолучитьАтрибут("СтатусУдаления");
		гТабКэшПараметровЗагрузки.СтатусПроводок				=	ПараметрыЗагрузки.ПолучитьАтрибут("СтатусПроводок");
		гТабКэшПараметровЗагрузки.СтатусПроведения				=	ПараметрыЗагрузки.ПолучитьАтрибут("СтатусПроведения");
		гТабКэшПараметровЗагрузки.СтатусРасчетныхДокументов		=	ПараметрыЗагрузки.ПолучитьАтрибут("СтатусРасчетныхДокументов");
		
		гТабКэшПараметровЗагрузки.ДатаТекущегоПериодаЖР			=	Дата(ПараметрыЗагрузки.ПолучитьАтрибут("ДатаТекущегоПериодаЖР"));
	
		гТабКэшПараметровЗагрузки.ЗамещатьНайденные				=	Число(ПараметрыЗагрузки.ПолучитьАтрибут("ЗамещатьНайденные"));
		гТабКэшПараметровЗагрузки.НовыеНеСоздавать				=	Число(ПараметрыЗагрузки.ПолучитьАтрибут("НовыеНеСоздавать"));
		
		гТабКэшПараметровЗагрузки.ЗагружатьОперации				=	Число(ПараметрыЗагрузки.ПолучитьАтрибут("ЗагружатьОперации"));
		гТабКэшПараметровЗагрузки.ЗагружатьЗаписиЖР				=	Число(ПараметрыЗагрузки.ПолучитьАтрибут("ЗагружатьЗаписиЖР"));
		                            	
	Иначе
		
		гТабКэшПараметровЗагрузки.ПолучитьСтрокуПоНомеру(НомСтр);
		
	КонецЕсли;
	
КонецПроцедуры		//	ЗагрузитьПараметрыЗагрузки()

//--------------------------------------------------------------------------------------------------

Процедура ЗагрузитьПравилоРеквизитов(Правило, Таб)
                                       
	Таб.НоваяСтрока();
	
	Источник					=	Правило.ВыбратьУзел("Источник");
	Приемник					=	Правило.ВыбратьУзел("Приемник");
	
	Таб.Ид						=	Правило.ПолучитьАтрибут("Ид");
	Таб.Преобразование			=	Правило.ПолучитьАтрибут("Преобразование");
	Таб.Правило					=	Правило.ПолучитьАтрибут("Правило");
	Таб.ЕстьПроцедура			=	Правило.ПолучитьАтрибут("ЕстьПроцедура");
	Таб.ПараметрыПравила		=	Правило.ПолучитьАтрибут("ПараметрыПравила");
	Таб.ПолучитьИзПараметров	=	Правило.ПолучитьАтрибут("ПолучитьИзПараметров");
	Таб.СпособВыгрузки			=	Правило.ПолучитьАтрибут("СпособВыгрузки");
	Таб.СпособЗагрузки			=	Правило.ПолучитьАтрибут("СпособЗагрузки");
	
	Условия						=	Правило.ВыбратьУзел("Условия");
	
	Если ПустоеЗначение(Источник) = 0 Тогда
		Таб.Источник_Ид				=	Источник.ПолучитьАтрибут("Ид");
		Таб.Источник_ТипАтрибута	=	Источник.ПолучитьАтрибут("ТипАтрибута");
		Таб.Источник_Тип			=	Источник.ПолучитьАтрибут("Тип");
		Таб.Источник_Вид			=	Источник.ПолучитьАтрибут("Вид");
		//Таб.Источник_Длина		=	Источник.ПолучитьАтрибут("Длина");
	КонецЕсли;

	Если ПустоеЗначение(Приемник) = 0 Тогда
		Таб.Приемник_Ид				=	Приемник.ПолучитьАтрибут("Ид");
		Таб.Приемник_ТипАтрибута	=	Приемник.ПолучитьАтрибут("ТипАтрибута");
		Таб.Приемник_Тип			=	Приемник.ПолучитьАтрибут("Тип");
		Таб.Приемник_Вид			=	Приемник.ПолучитьАтрибут("Вид");
		Таб.Приемник_Длина			=	Приемник.ПолучитьАтрибут("Длина");
	КонецЕсли;
	
	Если ПустоеЗначение(Условия) = 0 Тогда
		Таб.Условия	=	Условия;
		Если (ПустоеЗначение(Условия.ПолучитьАтрибут("ЗаданыПоРеквизиту")) = 1) И (Таб.Источник_ТипАтрибута <> "К") И (Таб.Источник_ТипАтрибута <> "ПК") Тогда
			Таб.ВидУсловия	=	1;
		Иначе
			Таб.ВидУсловия	=	2;
		КонецЕсли;
	КонецЕсли;
	
КонецПроцедуры		//	ЗагрузитьПравилоРеквизитов()

//--------------------------------------------------------------------------------------------------

Процедура ЗагрузитьПравилоРеквизитовЗначения(Правило, Ид="")
                                       
	Если		(ПустоеЗначение(Ид) = 1)	И (ПустоеЗначение(Правило) = 0)	Тогда
		Ид		=	Правило.ПолучитьАтрибут("Ид");
	ИначеЕсли	ПустоеЗначение(Ид) = 1		Тогда
		Возврат;
	КонецЕсли;
	
	НомСтр	=	"";
	
	Если  гТабКэшРеквизитовЗначений.НайтиЗначение(Ид, НомСтр, "Ид") = 0 Тогда
		                    
		гТабКэшРеквизитовЗначений.НоваяСтрока();
		
		Источник										=	Правило.ВыбратьУзел("Источник");
		Приемник										=	Правило.ВыбратьУзел("Приемник");
		
		гТабКэшРеквизитовЗначений.Ид					=	Ид;
		гТабКэшРеквизитовЗначений.Преобразование		=	Правило.ПолучитьАтрибут("Преобразование");
		гТабКэшРеквизитовЗначений.Правило				=	Правило.ПолучитьАтрибут("Правило");
		гТабКэшРеквизитовЗначений.ЕстьПроцедура			=	Правило.ПолучитьАтрибут("ЕстьПроцедура");
		гТабКэшРеквизитовЗначений.ПараметрыПравила		=	Правило.ПолучитьАтрибут("ПараметрыПравила");
		
		
		Условия											=	Правило.ВыбратьУзел("Условия");
		Если ПустоеЗначение(Условия) = 0 Тогда
			гТабКэшРеквизитовЗначений.Условия		=	Условия;
			гТабКэшРеквизитовЗначений.ВидУсловия	=	1;
			//Если ПустоеЗначение(Условия.ПолучитьАтрибут("ЗаданыПоРеквизиту")) = 1 Тогда
			//	гТабКэшРеквизитовЗначений.ВидУсловия	=	1;
			//Иначе
			//	гТабКэшРеквизитовЗначений.ВидУсловия	=	2;
			//КонецЕсли;
		КонецЕсли;
		
		
		Если ПустоеЗначение(Источник) = 0 Тогда
			гТабКэшРеквизитовЗначений.Источник_Ид		=	Источник.ПолучитьАтрибут("Ид");
			гТабКэшРеквизитовЗначений.Источник_Тип		=	Источник.ПолучитьАтрибут("Тип");
			гТабКэшРеквизитовЗначений.Источник_Вид		=	Источник.ПолучитьАтрибут("Вид");
		КонецЕсли;
	
		Если ПустоеЗначение(Приемник) = 0 Тогда
			гТабКэшРеквизитовЗначений.Приемник_Ид		=	Приемник.ПолучитьАтрибут("Ид");
			гТабКэшРеквизитовЗначений.Приемник_Тип		=	Приемник.ПолучитьАтрибут("Тип");
			гТабКэшРеквизитовЗначений.Приемник_Вид		=	Приемник.ПолучитьАтрибут("Вид");
			гТабКэшРеквизитовЗначений.Приемник_Длина	=	Приемник.ПолучитьАтрибут("Длина");
		КонецЕсли;
		
	Иначе
		
		гТабКэшРеквизитовЗначений.ПолучитьСтрокуПоНомеру(НомСтр);

	КонецЕсли;
										
КонецПроцедуры		//	ЗагрузитьПравилоРеквизитовЗначения()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция СистемноеПредставлениеОбъекта(Источник)
    
	//	Необходимо позиционироваться на объекты, т.к.
	//	если Источник - реквизит неопределенного типа,
	//	то ЗначениеВСтрокуВнутр - возвращает НЕСТАНДАРТНОЕ
	//	строковое представление !!!
	
	Тип	=	ТипЗначенияСтр(Источник);
	Стр	=	СокрЛП(Источник);
	
	Если		(Стр = "<Объект не найден>") Или (Стр = "") Тогда
		
		Возврат("");	//	Объект не существует в ИБ
		
	ИначеЕсли	Тип = "Справочник"	Тогда
		
		Об = СоздатьОбъект("Справочник." + Источник.Вид());
		Об.НайтиЭлемент(Источник);
		Возврат	ЗначениеВСтрокуВнутр(Об.ТекущийЭлемент());
		
	ИначеЕсли	Тип = "Документ"	Тогда
		
		Об = СоздатьОбъект("Документ." + Источник.Вид());
		Об.НайтиДокумент(Источник);
		Возврат	ЗначениеВСтрокуВнутр(Об.ТекущийДокумент());
		
	Иначе
		
		Об	=	Источник;
		Возврат	ЗначениеВСтрокуВнутр(Об);
		
	КонецЕсли;
	
КонецФункции		//	СистемноеПредставлениеОбъекта()

//--------------------------------------------------------------------------------------------------

Функция СоздатьУзелСсылки(Источник, ТабРеквизитовПоиска, ПараметрыПравила)
	
	//Если ТабРеквизитовПоиска.КоличествоСтрок() = 0 Тогда
	//	Возврат(1);
	//КонецЕсли;
    
	
	XML_DOM					=	гXMLАнализатор.СоздатьДокумент();
	УзелСсылки				=	XML_DOM.СоздатьУзел(1, "Ссылка");
	     
	ТипИсточника			=	ТипЗначенияСтр(Источник);
	
    Если (ТипИсточника = "Справочник") Или (ТипИсточника = "Счет") Тогда
		ЭтоГруппа	=	Источник.ЭтоГруппа();
		УстановитьАтрибут(УзелСсылки,	"ЭтоГруппа",	ЭтоГруппа);
    КонецЕсли;
	
	Если ТабРеквизитовПоиска.КоличествоСтрок() > 0 Тогда
		ТабРеквизитовПоиска.ВыбратьСтроки();
		Пока ТабРеквизитовПоиска.ПолучитьСтроку() = 1 Цикл
			Результат	=	ДобавитьРеквизит(ТабРеквизитовПоиска, Источник, УзелСсылки, "#Получить", "Поиск", ПараметрыПравила);
			Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
		КонецЦикла;
	Иначе
		УстановитьАтрибут(УзелСсылки, "СистемныйИд", УзелСсылки.ПреобразоватьВ_ИД(СистемноеПредставлениеОбъекта(Источник)));
	КонецЕсли;
	
	Возврат(УзелСсылки);
	
КонецФункции	//	СоздатьУзелСсылки()
                        
//--------------------------------------------------------------------------------------------------

Функция ОбъектУжеВыгружен(Источник, ТабРеквизитовПоиска, ИдПравила, УзелСсылки, Режим=0, ПараметрыПравила="", НовыеНеСоздавать=0, НеСинхронизироватьПоДопПараметрам=0)
	
	Перем	НомСтр;
	
	
	Если (ФормФлЗапоминатьСсылки = 0) И (Режим <> "Проведение") Тогда
		УзелСсылки	=	СоздатьУзелСсылки(Источник, ТабРеквизитовПоиска, ПараметрыПравила);
		Если НовыеНеСоздавать = 1 Тогда Возврат(1) КонецЕсли;	//	в данном случае нам нужна только ссылка
	КонецЕсли;
	
	
	//СписокВыгруженныхОбъектов = СписокСписковВыгруженныхОбъектов.Получить(ИдПравила);

	Если ТабВыгруженныхОбъектов.НайтиЗначение(ИдПравила, НомСтр, "ИдПравила") = 0 Тогда
		Если Режим = "Проведение" Тогда Возврат(0) КонецЕсли;
		ТабВыгруженныхОбъектов.НоваяСтрока();
		ТабВыгруженныхОбъектов.ИдПравила	=	ИдПравила;
		ТабВыгруженныхОбъектов.ТабОбъектов	=	СоздатьОбъект("ТаблицаЗначений");
		ТабОбъектов							=	ТабВыгруженныхОбъектов.ТабОбъектов;
		ТабОбъектов.НоваяКолонка("Объект");
		Если ФормФлЗапоминатьСсылки = 1 Тогда
			ТабОбъектов.НоваяКолонка("Ссылка",	"Строка");
		КонецЕсли;
	Иначе
		ТабОбъектов							=	ТабВыгруженныхОбъектов.ПолучитьЗначение(НомСтр, "ТабОбъектов");
	КонецЕсли;
	
	//Если ТипЗначенияСтр(СписокВыгруженныхОбъектов) <> "СписокЗначений" Тогда
	//	Если Режим = "Проведение" Тогда Возврат(0) КонецЕсли;
	//	СписокВыгруженныхОбъектов = СоздатьОбъект("СписокЗначений");
	//	СписокСписковВыгруженныхОбъектов.Установить(ИдПравила, СписокВыгруженныхОбъектов);
	//КонецЕсли;
                                                       
	
	Если ПустоеЗначение(СокрЛП(Источник)) = 1 Тогда
		СистПредставление = ИдПравила + ?(ПустоеЗначение(ПараметрыПравила)=0, ЗначениеВСтрокуВнутр(ПараметрыПравила), "");
	Иначе
		Если (ПустоеЗначение(ПараметрыПравила)=0) И (НеСинхронизироватьПоДопПараметрам=0) Тогда
			
			//Тип	=	ТипЗначенияСтр(Источник);
			//Если		СокрЛП(Источник) = "<Объект не найден>" Тогда
			//	//	Объект не существует в ИБ
			//	Об					=	Источник;
			//	СистПредставление	=	"";
			//ИначеЕсли	Тип = "Справочник"	Тогда
			//	Об = СоздатьОбъект("Справочник." + Источник.Вид());
			//	Об.НайтиЭлемент(Источник);
			//	СистПредставление	=	ЗначениеВСтрокуВнутр(Об.ТекущийЭлемент());
			//ИначеЕсли	Тип = "Документ"	Тогда
			//	Об = СоздатьОбъект("Документ");
			//	Об.НайтиДокумент(Источник);
			//	СистПредставление	=	ЗначениеВСтрокуВнутр(Об.ТекущийДокумент());
			//Иначе
			//	Об					=	Источник;
			//	СистПредставление	=	ЗначениеВСтрокуВнутр(Об);
			//КонецЕсли;
			//СистПредставление		=	СистПредставление + ЗначениеВСтрокуВнутр(ПараметрыПравила);
			                                                                                       
			СистПредставление		=	СистемноеПредставлениеОбъекта(Источник) + ЗначениеВСтрокуВнутр(ПараметрыПравила);
			
		Иначе
			СистПредставление	=	Источник;
		КонецЕсли;
	КонецЕсли;

	
	НомСтр = "";
	Если ТабОбъектов.НайтиЗначение(СистПредставление, НомСтр, "Объект") = 0 Тогда
		
		Если Режим = "Проведение" Тогда Возврат(0) КонецЕсли;
		
		Если ФормФлЗапоминатьСсылки = 1 Тогда
			УзелСсылки				=	СоздатьУзелСсылки(Источник, ТабРеквизитовПоиска, ПараметрыПравила);
			
			ТабОбъектов.НоваяСтрока();
			ТабОбъектов.Объект	=	СистПредставление;
			
			Если УзелСсылки <> 1 Тогда
				ТабОбъектов.Ссылка	=	УзелСсылки.ПредставлениеXML;
				//ТабОбъектов.УстановитьЗначение(НомерНовойСтроки, "Ссылка", УзелСсылки.ПредставлениеXML);
			КонецЕсли;
		Иначе
			ТабОбъектов.НоваяСтрока();
			ТабОбъектов.Объект = СистПредставление;
		КонецЕсли;
		
		Если НовыеНеСоздавать = 1 Тогда Возврат(1) КонецЕсли;	//	в данном случае нам нужна только ссылка
		
		Возврат(0);
		
	ИначеЕсли	ФормФлЗапоминатьСсылки = 1	Тогда
		                            
		СтрСсылка	=	ТабОбъектов.ПолучитьЗначение(НомСтр, "Ссылка");
		Если ПустоеЗначение(СтрСсылка) = 0 Тогда
			XML_DOM		=	гXMLАнализатор.СоздатьДокумент();
			XML_DOM.ЗагрузитьИзСтроки(СтрСсылка);
			УзелСсылки	=	XML_DOM.ВыбратьУзел("Ссылка");
		КонецЕсли;
		
	Иначе
	    
		Если Режим = "Проведение" Тогда
			УзелСсылки = СоздатьУзелСсылки(Источник, ТабРеквизитовПоиска, ПараметрыПравила);
		КонецЕсли;
		
	КонецЕсли;
	    
	Возврат(1);
	
КонецФункции		//	ОбъектУжеВыгружен()

//--------------------------------------------------------------------------------------------------

Процедура ЗаписатьОбъектВФайл(XML_DOM);
    
	гСчетчикВыгруженныхОбъектов	=	гСчетчикВыгруженныхОбъектов + 1;
	
	XML_DOM.УстановитьАтрибут("Нпп", гСчетчикВыгруженныхОбъектов);
	
    гФайлДанных.ВключитьЭлемент(XML_DOM);
	                                   
	
	Если гСчетчикВыгруженныхОбъектов % ФормКолвоБуферизуемыхОбъектов = 0 Тогда
		гФайлДанных.Сбросить();
	КонецЕсли;
	
	Если гСчетчикВыгруженныхОбъектов % 10 = 0 Тогда	Состояние("Выгружено объектов:    " + гСчетчикВыгруженныхОбъектов) КонецЕсли;
	
КонецПроцедуры

//--------------------------------------------------------------------------------------------------

Функция ПометкаУдаления(Источник, СтатусУдаления)
                                
	Если ПустоеЗначение(Источник) = 1 Тогда Возврат(0) КонецЕсли;
	
	Если		СтатусУдаления	= "Авто"			Тогда
		
		Возврат(Источник.ПометкаУдаления());
		
	//ИначеЕсли СтатусУдаления	= "Пометить"		Тогда	// это можно прочитать из правил...
	//ИначеЕсли СтатусУдаления	= "СнятьПометку"	Тогда
	
	КонецЕсли;
	
	Возврат(0);
	
КонецФункции		//	ПометкаУдаления()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ВыключитьПроводки(Источник, СтатусПроводок)
	
	Если		СтатусПроводок	= "Авто"			Тогда	//	на бух. учет и СуществуетОперация() проверили раньше
		 
		Возврат(1 - Источник.Операция.ВключитьПроводки());
		
	//ИначеЕсли СтатусУдаления	= "Включить "		Тогда	// это можно прочитать из правил...
	//ИначеЕсли СтатусУдаления	= "Выключить "		Тогда
	
	КонецЕсли;
	
	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

Функция ОтменитьПроведение(Источник, СтатусПроведения);
	
	Если		СтатусПроведения	= "Авто"				Тогда
		
		Если Источник.ПометкаУдаления() = 1 Тогда Возврат(0) КонецЕсли;
		
		Если Метаданные.Документ(Источник.Вид()).РазрешитьПроведение = 0 Тогда
			Возврат(0);
		КонецЕсли;
		 
		Возврат( 1 - Источник.Проведен() );
		
	//ИначеЕсли СтатусПроведения	= "Провести"			Тогда	// это можно прочитать из правил...
	//ИначеЕсли СтатусПроведения	= "ОтменитьПроведение"	Тогда
	
	КонецЕсли;
	
	Возврат(0);
	
КонецФункции		//	ОтменитьПроведение()

//--------------------------------------------------------------------------------------------------

Функция НужноПровести(Источник, СтатусПроведения)
	                                             
	//Если Источник.ПометкаУдаления() = 1 Тогда Возврат(0) КонецЕсли;
	
	Если		СтатусПроведения	= "Авто"			Тогда
		     
		ВидДокумента	=	Источник.Вид();
		
		Если		ВидДокумента = "Операция" Тогда
			Возврат(1);
		ИначеЕсли	Метаданные.Документ(ВидДокумента).РазрешитьПроведение = 0 Тогда
			Возврат(0);
		КонецЕсли;
		 
		Возврат( Источник.Проведен() );
		
	ИначеЕсли СтатусПроведения	= "Провести"			Тогда
		
		Возврат(1);
		
	ИначеЕсли СтатусПроведения	= "ОтменитьПроведение"	Тогда
	
	КонецЕсли;
	
	Возврат(0);

КонецФункции		//	НужноПровести()
                      
//--------------------------------------------------------------------------------------------------

Процедура ЗагрузитьПравило(Правило, Ид="")
                                       
	Если		(ПустоеЗначение(Ид) = 1)	И (ПустоеЗначение(Правило) = 0)	Тогда
		Ид		=	Правило.ПолучитьАтрибут("Ид");
	ИначеЕсли	ПустоеЗначение(Ид) = 1		Тогда
		Возврат;
	КонецЕсли;
	
	НомСтр	=	"";
	
	Если  гТабКэшПравил.НайтиЗначение(Ид, НомСтр, "Ид") = 0 Тогда
		
		Если		ПустоеЗначение(Правило) = 1	Тогда
			Правило	=	гПравила.ВыбратьУзел("//Правило[@Ид=""" + Ид + """]");
		КонецЕсли;
		
		Источник									=	Правило.ВыбратьУзел("ОбъектИсточник");
		Приемник									=	Правило.ВыбратьУзел("ОбъектПриемник");
		
		гТабКэшПравил.НоваяСтрока();
		гТабКэшПравил.Ид							=	Ид;
		гТабКэшПравил.Правило						=	Правило;
		гТабКэшПравил.ПоСсылкам						=	Число(Правило.ПолучитьАтрибут("ПоСсылкам"));
		гТабКэшПравил.Преобразование				=	Правило.ПолучитьАтрибут("Преобразование");
		гТабКэшПравил.ПравилоПереадресации			=	Правило.ПолучитьАтрибут("Правило");
		гТабКэшПравил.ПараметрыЗагрузки				=	Правило.ПолучитьАтрибут("ПараметрыЗагрузки");
		гТабКэшПравил.ИдСинхронизирующегоРеквизита	=	Правило.ПолучитьАтрибут("ИдСинхронизирующегоРеквизита");
		
		Условия										=	Правило.ВыбратьУзел("Условия");
		Если ПустоеЗначение(Условия) = 0 Тогда
			гТабКэшПравил.Условия		=	Условия;
			гТабКэшПравил.ВидУсловия	=	1;
		КонецЕсли;
		                            	
		Если ПустоеЗначение(Источник) = 0 Тогда
			гТабКэшПравил.Источник_Тип				=	Источник.ПолучитьАтрибут("Тип");
			гТабКэшПравил.Источник_Вид				=	Источник.ПолучитьАтрибут("Вид");
		КонецЕсли;
	
		Если ПустоеЗначение(Приемник) = 0 Тогда
			гТабКэшПравил.Приемник_Тип				=	Приемник.ПолучитьАтрибут("Тип");
			гТабКэшПравил.Приемник_Вид				=	Приемник.ПолучитьАтрибут("Вид");
			Если гТабКэшПравил.Приемник_Тип = "ЖурналРасчетов" Тогда
				гТабКэшПравил.Уникальность			=	Приемник.ПолучитьАтрибут("Уникальность");
				гТабКэшПравил.ДатаОтсчета			=	Приемник.ПолучитьАтрибут("ДатаОтсчета");
			КонецЕсли;
		КонецЕсли;
		
		Приемник_Тип								=	гТабКэшПравил.Приемник_Тип;
		Источник_Тип								=	гТабКэшПравил.Источник_Тип;
		//Если ПустоеЗначение(Приемник_Тип) = 1 Тогда Возврат КонецЕсли;
		
		//-------------------------------------------
		
		гТабКэшПравил.ТабРеквизитовПоиска			=	СоздатьОбъект("ТаблицаЗначений");
		гТабКэшПравил.ТабРеквизитов					=	СоздатьОбъект("ТаблицаЗначений");
		гТабКэшПравил.ТабРеквизитовСтрок			=	СоздатьОбъект("ТаблицаЗначений");
		
		Реквизиты = Правило.ВыбратьУзлы("Реквизит[@СпособЗагрузки=""Поиск""]");
		Если ПустоеЗначение(Реквизиты.КоличествоУзлов()) = 0 Тогда
			гТабКэшПравил.ТабРеквизитовПоиска.Загрузить(гТабКэшРеквизитов);
			Для СчРеквизитов = 0 По Реквизиты.КоличествоУзлов() - 1 Цикл
				ЗагрузитьПравилоРеквизитов(Реквизиты.ПолучитьУзел(СчРеквизитов), гТабКэшПравил.ТабРеквизитовПоиска);
			КонецЦикла;
		КонецЕсли;
		
		Если		Приемник_Тип = "Справочник"	Тогда
        	Запрос	=	"Реквизит[(@СпособЗагрузки != ""Поиск"") or (not(@СпособЗагрузки))]";
		ИначеЕсли	Приемник_Тип = "Документ"	Тогда
			Запрос	=	"Реквизит[( (@СпособЗагрузки != ""Поиск"") or (not(@СпособЗагрузки)) ) and ( (Приемник/@ТипАтрибута != ""РТД"") or (not(Приемник)) ) and ( (@СпособВыгрузки != ""ПеребратьСтрокиДокумента"") or (not(СпособВыгрузки)) )]";
		ИначеЕсли	Приемник_Тип = "Операция"	Тогда
			Запрос	=	"Реквизит[ (Приемник/@ТипАтрибута = ""АО"") or (Приемник/@ТипАтрибута = ""РО"") ]";
		ИначеЕсли	(ПустоеЗначение(Приемник_Тип) = 1) И (Источник_Тип = "Документ")	Тогда
			Запрос	=	"Реквизит[(@СпособВыгрузки != ""ПеребратьСтрокиДокумента"")]";
		Иначе
			Запрос	=	"Реквизит";
		КонецЕсли;
		
		Реквизиты = Правило.ВыбратьУзлы(Запрос);
		Если ПустоеЗначение(Реквизиты.КоличествоУзлов()) = 0 Тогда
			гТабКэшПравил.ТабРеквизитов.Загрузить(гТабКэшРеквизитов);
			Для СчРеквизитов = 0 По Реквизиты.КоличествоУзлов() - 1 Цикл
				ЗагрузитьПравилоРеквизитов(Реквизиты.ПолучитьУзел(СчРеквизитов), гТабКэшПравил.ТабРеквизитов);
			КонецЦикла;
		КонецЕсли;
		
		Если		Приемник_Тип = "Документ"	Тогда
			Запрос	=	"Реквизит[( (@СпособЗагрузки != ""Поиск"") or (not(@СпособЗагрузки)) ) and ( (Приемник/@ТипАтрибута = ""РТД"") or (@СпособВыгрузки = ""ПеребратьСтрокиДокумента"") )]";
		ИначеЕсли	Приемник_Тип = "Операция"	Тогда
			//Запрос	=	"Реквизит[ (Приемник/@ТипАтрибута != ""АО"") and (Приемник/@ТипАтрибута != ""РО"") ]";
			Запрос	=	"Реквизит[( (Приемник/@ТипАтрибута != ""АО"") and (Приемник/@ТипАтрибута != ""РО"") ) or (@СпособВыгрузки = ""ПеребратьСтрокиДокумента"")]";
		ИначеЕсли	(ПустоеЗначение(Приемник_Тип) = 1) И (Источник_Тип = "Документ")	Тогда
			Запрос	=	"Реквизит[(@СпособВыгрузки = ""ПеребратьСтрокиДокумента"")]";
		Иначе
			Запрос	=	"";
		КонецЕсли;
		
		Если Запрос <> "" Тогда
			Реквизиты	=	Правило.ВыбратьУзлы(Запрос);
			Если ПустоеЗначение(Реквизиты.КоличествоУзлов()) = 0 Тогда
				гТабКэшПравил.ТабРеквизитовСтрок.Загрузить(гТабКэшРеквизитов);
				Для СчРеквизитов = 0 По Реквизиты.КоличествоУзлов() - 1 Цикл
					ЗагрузитьПравилоРеквизитов(Реквизиты.ПолучитьУзел(СчРеквизитов), гТабКэшПравил.ТабРеквизитовСтрок);
				КонецЦикла;
			КонецЕсли;
		КонецЕсли;
		
	Иначе
		
		гТабКэшПравил.ПолучитьСтрокуПоНомеру(НомСтр);
		Если		ПустоеЗначение(Правило) = 1	Тогда
			Правило	=	гТабКэшПравил.Правило;			//  нужно для поиска значений и др.
		КонецЕсли;
		
	КонецЕсли;
	
КонецПроцедуры		//	ЗагрузитьПравило()

//--------------------------------------------------------------------------------------------------

Функция НайтиПравило(Источник, Правило="", ИдПравила="", ТипПриемника="", ВидПриемника="", ИдПравилаДок="")
	          
	ЗагрузитьПравило(Правило, ИдПравила);
	
	Если ПустоеЗначение(Правило) = 0 Тогда
		Если гТабКэшПравил.ВидУсловия = 1 Тогда	//	т.е. условие задано
			Если УсловияВыполняются(гТабКэшПравил.Условия, Источник, ИдПравилаДок) = 0 Тогда Возврат(0) КонецЕсли;
		КонецЕсли;
		Возврат(1);
	КонецЕсли;
	
	Вид				=	"";
	Запрос			=	"";
	
	Тип				=	ТипЗначенияСтр(Источник);
	
	
	Если	ПустоеЗначение(Тип) = 1									Тогда Возврат(0) КонецЕсли;
	Если	(Тип = "Строка") И (ТипПриемника = "Неопределенный")	Тогда Возврат(0) КонецЕсли;
	
	
	Запрос			=	Запрос + "//Правило[(ОбъектИсточник/@Тип = """ + Тип + """)";
	
	Если (Найти("Строка,Число,Дата,Операция,Календарь,ВидСубконто,ВидРасчета", Тип) = 0) И (Тип <> "ПланСчетов") Тогда
		Вид			=	Источник.Вид();
		Запрос		=	Запрос + "and(ОбъектИсточник/@Вид = """ + Вид + """)";
	КонецЕсли;
	
	Если (ПустоеЗначение(ТипПриемника) = 0) И (ТипПриемника <> "Неопределенный") Тогда
		Запрос		=	Запрос + "and(ОбъектПриемник/@Тип = """ + ТипПриемника + """)";
		Если ПустоеЗначение(ВидПриемника) = 0 Тогда
			Запрос	=	Запрос + "and(ОбъектПриемник/@Вид = """ + ВидПриемника + """)";
		КонецЕсли;
	КонецЕсли;
	
	Запрос			=	Запрос + "]";
	                     
	ВыборкаПравил	=	гПравила.ВыбратьУзлы(Запрос);
	Для Сч = 0 По ВыборкаПравил.КоличествоУзлов() - 1 Цикл
		ВыбПравило	=	ВыборкаПравил.ПолучитьУзел(Сч);
		ИдПравила	=	"";
		ЗагрузитьПравило(ВыбПравило, ИдПравила);
		Если гТабКэшПравил.ВидУсловия = 1 Тогда	//	т.е. условие задано
			Если УсловияВыполняются(гТабКэшПравил.Условия, Источник, ИдПравилаДок) = 1 Тогда
				Правило	=	ВыбПравило;
				Возврат(1);
			КонецЕсли;
		Иначе
			Правило	=	ВыбПравило;
			Возврат(1);
		КонецЕсли;
	КонецЦикла;
		       
	
	Если Тип <> "ЖурналРасчетов" Тогда
		ЗаписатьОшибку("Не найдено правило конвертации объекта: " + Тип + "." + Вид + " - " + Источник, "!!");
	КонецЕсли;
	
	
	Возврат(0);
	
КонецФункции		//	НайтиПравило()
            
//--------------------------------------------------------------------------------------------------

Функция НайтиПравилоДляАтрибутаЗначения(Знач Источник, Правило="", ИдПравила="", ПравилоАтрибутаЗначения="")
	              
	Если (ПустоеЗначение(ИдПравила) = 1) И (ПустоеЗначение(ПравилоАтрибутаЗначения) = 0) Тогда
		ИдПравила	=	ПравилоАтрибутаЗначения.ПолучитьАтрибут("Правило");
	КонецЕсли;
	
	ЗагрузитьПравило(Правило, ИдПравила);
	
	Если ПустоеЗначение(Правило) = 0 Тогда
		Если гТабКэшПравил.ВидУсловия = 1 Тогда	//	т.е. условие задано
			Если УсловияВыполняются(гТабКэшПравил.Условия, Источник) = 0 Тогда Возврат(0) КонецЕсли;
		КонецЕсли;
		Возврат(1);
	КонецЕсли;
	
	Если ПустоеЗначение(ПравилоАтрибутаЗначения) = 1 Тогда Возврат(0) КонецЕсли;
	
	Запрос				=	"";
	Источник_Тип		=	"";
	Источник_Вид		=	"";
	Приемник_Тип		=	"";
	Приемник_Вид		=	"";
	
	УзелИсточник		=	ПравилоАтрибутаЗначения.ВыбратьУзел("Источник");
	УзелПриемник		=	ПравилоАтрибутаЗначения.ВыбратьУзел("Приемник");
	
	Если ПустоеЗначение(УзелИсточник) = 0 Тогда
		Источник_Тип	=	УзелИсточник.ПолучитьАтрибут("Тип");
		Источник_Вид	=	УзелИсточник.ПолучитьАтрибут("Вид");
	КонецЕсли;

	Если ПустоеЗначение(УзелПриемник) = 0 Тогда
		Приемник_Тип	=	УзелПриемник.ПолучитьАтрибут("Тип");
		Приемник_Вид	=	УзелПриемник.ПолучитьАтрибут("Вид");
	КонецЕсли;
	            
	Если ПустоеЗначение(Приемник_Тип) = 1 Тогда Возврат(0)								КонецЕсли;
	Если ПустоеЗначение(Источник_Тип) = 1 Тогда Источник_Тип = ТипЗначенияСтр(Источник)	КонецЕсли;
	Если ПустоеЗначение(Источник_Тип) = 1 Тогда Возврат(0) 								КонецЕсли;

	Запрос			=	Запрос + "//Правило[(ОбъектИсточник/@Тип = """ + Источник_Тип + """)";
	
	Если Найти("Строка,Число,Дата,Операция", Источник_Тип) = 0 Тогда
		Если ПустоеЗначение(Источник_Вид) = 1 Тогда Источник_Вид = Источник.Вид() КонецЕсли;
		Запрос		=	Запрос + "and(ОбъектИсточник/@Вид = """ + Источник_Вид + """)";
	КонецЕсли;
	
	Запрос			=	Запрос + "and(ОбъектПриемник/@Тип = """ + Приемник_Тип + """)";
	
	Если Найти("Строка,Число,Дата,Операция", Приемник_Тип) = 0 Тогда
		Если ПустоеЗначение(Приемник_Вид) = 1 Тогда Приемник_Вид = Источник_Вид КонецЕсли;
		Запрос		=	Запрос + "and(ОбъектПриемник/@Вид = """ + Приемник_Вид + """)";
	КонецЕсли;
	
	Запрос			=	Запрос + "]";
	                     
	ВыборкаПравил	=	гПравила.ВыбратьУзлы(Запрос);
	Для Сч = 0 По ВыборкаПравил.КоличествоУзлов() - 1 Цикл
		ВыбПравило	=	ВыборкаПравил.ПолучитьУзел(Сч);
		ИдПравила	=	"";
		ЗагрузитьПравило(ВыбПравило, ИдПравила);
		Если гТабКэшПравил.ВидУсловия = 1 Тогда	//	т.е. условие задано
			Если УсловияВыполняются(гТабКэшПравил.Условия, Источник) = 1 Тогда
				Правило	=	ВыбПравило;
				Возврат(1);
			КонецЕсли;
		Иначе
			Правило	=	ВыбПравило;
			Возврат(1);
		КонецЕсли;
	КонецЦикла;
		
	ЗаписатьОшибку("Не найдено правило конвертации атрибута значения: " + ПравилоАтрибутаЗначения.ПолучитьАтрибут("Имя") + " - " + Источник_Тип + "." + Источник_Вид + " - " + Источник, "!!");
	Возврат(0);
	
КонецФункции		//	НайтиПравилоДляАтрибутаЗначения()

//--------------------------------------------------------------------------------------------------

Функция ПолучитьЗначениеМетодом(Источник, Метод)
                                        
	Если ПустоеЗначение(СокрЛП(Источник)) = 1 Тогда Возврат("") КонецЕсли;
	    
	Если		Метод = "Значение()"				Тогда
		Возврат		Источник;
	ИначеЕсли	Метод = "Вид()"						Тогда
		Возврат		Источник.Вид();
	ИначеЕсли	Метод = "ПометкаУдаления()"			Тогда
		Возврат		Источник.ПометкаУдаления();
	ИначеЕсли	Метод = "СистемноеПредставление()"	Тогда
		Возврат		ЗначениеВСтрокуВнутр(Источник);
	ИначеЕсли	Метод = "Код()"						Тогда
		Возврат		Источник.Код;
	КонецЕсли;
	
	
	ТипИсточника	=	ТипЗначенияСтр(Источник);
	
	
    Если		ТипИсточника = "Справочник"			Тогда
		      
		Если		Метод = "ТекущийЭлемент()"		Тогда
			Зн	=	Источник.ТекущийЭлемент();
		ИначеЕсли	Метод = "ЭтоГруппа()"			Тогда
			Зн	=	Источник.ЭтоГруппа();
		КонецЕсли;
		                                     
	ИначеЕсли	ТипИсточника = "Документ"			Тогда

		Если		Метод = "ТекущийДокумент()"		Тогда
			//Зн	=	Источник.ТекущийДокумент();
			Возврат(Источник);
		ИначеЕсли	Метод = "Проведен()"			Тогда
			Зн	=	Источник.Проведен();
		ИначеЕсли	Метод = "ПроводкиВключены()"	Тогда
			Зн	=	Источник.Операция.ВключитьПроводки();
		КонецЕсли;
		
	ИначеЕсли	ТипИсточника = "Перечисление"		Тогда
		
		Если			Метод = "ТекущееЗначение()"	Тогда
			Зн	=	Источник;
		ИначеЕсли		Метод = "Представление()"	Тогда
			Зн	=	Строка(Источник);
		ИначеЕсли		Метод = "Идентификатор()"	Тогда
			Зн	=	Источник.Идентификатор();
		ИначеЕсли		Метод = "ПорядковыйНомер()"	Тогда
			Зн	=	Источник.ПорядковыйНомер();
		КонецЕсли;
		
	ИначеЕсли	ТипИсточника = "Счет"				Тогда
		
		Если		Метод = "ТекущийСчет()"			Тогда
			Зн	=	Источник.ТекущийСчет();
		ИначеЕсли	Метод = "Родитель()"			Тогда
			Зн	=	Источник.Родитель();
		ИначеЕсли	Найти(Метод, "ВидСубконто") > 0	Тогда
			НомерСубконто	=	Число(Сред(Метод, 12, 1));
			Если НомерСубконто > МаксимальноеКоличествоСубконто() Тогда
				Возврат("");
			КонецЕсли;
			Зн	=	Источник.ВидСубконто(НомерСубконто);
		КонецЕсли;
	
	ИначеЕсли	ТипИсточника = "ВидСубконто"		Тогда
		
		Если		Метод = "Идентификатор()"		Тогда
			Зн	=	Источник.Идентификатор();
		ИначеЕсли	Метод = "Представление()"		Тогда
			Зн	=	Метаданные.ВидСубконто(Источник.Идентификатор()).Представление();
		ИначеЕсли	Метод = "ТипСубконто()"			Тогда
			Зн	=	Источник.ТипСубконто();
		ИначеЕсли	Метод = "ПорядковыйНомер()"		Тогда
			Зн	=	Источник.ПорядковыйНомер();
		КонецЕсли;
		
	ИначеЕсли	ТипИсточника = "Операция"			Тогда

		Если		Метод = "ПланСчетов()"			Тогда
			Если Источник.ПроводкаВыбрана() = 1 Тогда
				Зн	=	Источник.ПланСчетов().Идентификатор();
			Иначе
				ЗаписатьОшибку("Не выбрана проводка для получения плана счетов!", "!");
			КонецЕсли;
		ИначеЕсли	Метод = "ВидДокумента()"		Тогда
			Зн	=	Источник.Документ.Вид();
		КонецЕсли;
		
	КонецЕсли;
	
	Возврат(Зн);
	
КонецФункции		//	ПолучитьЗначениеМетодом()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ПодобратьЗначениеПоТипу(Объект, ТипЗнач, ВидЗнач, НомерСубконтоИсточника="")
	
	Если  		ТипЗначенияСтр(Объект) = "СписокЗначений" Тогда
		
		Для Сч = 1 По Объект.РазмерСписка() Цикл
			Значение = Объект.ПолучитьЗначение(Сч);
			Если ТипЗначенияСтр(Значение) = ТипЗнач	Тогда
				Если Найти("Строка,Число,Дата", ТипЗнач) = 0 Тогда
				    Если Значение.Вид() = ВидЗнач Тогда	Возврат(Значение)	КонецЕсли;
				КонецЕсли;
			КонецЕсли;
		КонецЦикла;
		
	ИначеЕсли  	ТипЗначенияСтр(Объект) = "Справочник" Тогда
	                                                       
		ОбъектМД	=	Метаданные.Справочник(Объект.Вид());
		
		Если ПустоеЗначение(НомерСубконтоИсточника) = 0 Тогда
			ИдРеквизита	=	"Субконто" + СокрЛП(НомерСубконтоИсточника);
			Если ОбъектМД.Реквизит(ИдРеквизита).Выбран() = 1 Тогда
				Возврат	Объект.ПолучитьАтрибут(ИдРеквизита);
			КонецЕсли;
		КонецЕсли;
		
		Для Сч = 1 По ОбъектМД.Реквизит() Цикл
		    РеквМД	=	ОбъектМД.Реквизит(Сч);
			Если РеквМД.Тип = "Неопределенный" Тогда
				Значение = Объект.ПолучитьАтрибут(РеквМД.Идентификатор);
				Если ТипЗначенияСтр(Значение) = ТипЗнач	Тогда
					Если Найти("Строка,Число,Дата", ТипЗнач) = 0 Тогда
					    Если Значение.Вид() = ВидЗнач Тогда	Возврат(Значение)	КонецЕсли;
					КонецЕсли;
				КонецЕсли;
			КонецЕсли;
		КонецЦикла;
		
	ИначеЕсли	ТипЗначенияСтр(Объект) = "Документ" Тогда
		
		ОбъектМД	=	Метаданные.Документ(Объект.Вид());
		
		Если ПустоеЗначение(НомерСубконтоИсточника) = 0 Тогда
			ИдРеквизита	=	"Субконто" + СокрЛП(НомерСубконтоИсточника);
			Если		ОбъектМД.РеквизитШапки(ИдРеквизита).Выбран() = 1 Тогда
				Возврат	Объект.ПолучитьАтрибут(ИдРеквизита);
			ИначеЕсли	ОбъектМД.РеквизитТабличнойЧасти(ИдРеквизита).Выбран() = 1 Тогда
				Возврат	Объект.ПолучитьАтрибут(ИдРеквизита);
			КонецЕсли;
		КонецЕсли;
		
		Для Сч = 1 По ОбъектМД.РеквизитШапки() Цикл
		    РеквМД	=	ОбъектМД.РеквизитШапки(Сч);
			Если РеквМД.Тип = "Неопределенный" Тогда
				Значение = Объект.ПолучитьАтрибут(РеквМД.Идентификатор);
				Если ТипЗначенияСтр(Значение) = ТипЗнач	Тогда
					Если Найти("Строка,Число,Дата", ТипЗнач) = 0 Тогда
					    Если Значение.Вид() = ВидЗнач Тогда	Возврат(Значение)	КонецЕсли;
					КонецЕсли;
				КонецЕсли;
			КонецЕсли;
		КонецЦикла;
		
		Для Сч = 1 По ОбъектМД.РеквизитТабличнойЧасти() Цикл
		    РеквМД	=	ОбъектМД.РеквизитТабличнойЧасти(Сч);
			Если РеквМД.Тип = "Неопределенный" Тогда
				Значение = Объект.ПолучитьАтрибут(РеквМД.Идентификатор);
				Если ТипЗначенияСтр(Значение) = ТипЗнач	Тогда
					Если Найти("Строка,Число,Дата", ТипЗнач) = 0 Тогда
					    Если Значение.Вид() = ВидЗнач Тогда	Возврат(Значение)	КонецЕсли;
					КонецЕсли;
				КонецЕсли;
			КонецЕсли;
		КонецЦикла;
		
	КонецЕсли;
	
	Возврат("");

КонецФункции		//	ПодобратьЗначениеПоТипу()

//-------------------------------------------------------------------------------------------------- 
             
Функция ВыделитьПрефикс(Знач Стр, ЧисловаяЧасть="", Режим="")
    
	Стр		=	СокрЛП(Стр);
	Префикс	=	Стр;
	Длина	=	СтрДлина(Стр);
	
	Для Сч = 1 По Длина Цикл
		ЧисловаяЧасть	=	Число(Стр);
		
	    Если (ЧисловаяЧасть > 0) И (СтрДлина(ЧисловаяЧасть) = Длина - Сч + 1) Тогда 
			Префикс	=	Лев(Префикс, Сч - 1);
			
			Пока Прав(Префикс, 1) = "0" Цикл
			    Префикс = Лев(Префикс, СтрДлина(Префикс)-1);
			КонецЦикла;
			
			Прервать;		    				
	    Иначе
			Стр = Прав(Стр, Длина - Сч);
		КонецЕсли;
		
		Если ЧисловаяЧасть < 0 Тогда	ЧисловаяЧасть = - ЧисловаяЧасть		КонецЕсли;
			
	КонецЦикла;
	              
	Если Режим = "Число" Тогда
	    Возврат(ЧисловаяЧасть);
	Иначе
		Возврат(Префикс);
	КонецЕсли;

КонецФункции		//	ВыделитьПрефикс()

//--------------------------------------------------------------------------------------------------

Функция ДополнитьНулями(Стр, Длина)
                            
	Стр			=	СокрЛП(Стр);
	//Добавить	=	Длина - СтрДлина(Стр);
	
	//Если	Добавить > 0	Тогда
		
		ЧисловаяЧасть	=	"";
		Результат		=	ВыделитьПрефикс(Стр, ЧисловаяЧасть);
		Пока Длина - СтрДлина(Результат) - СтрДлина(ЧисловаяЧасть) > 0 Цикл
		    Результат	=	Результат + "0";
		КонецЦикла;
		Результат	=	Результат + Строка(ЧисловаяЧасть);
		
		Возврат(Результат);
		
	//Иначе
	//	Возврат	Стр;
	//КонецЕсли;
	
КонецФункции		//	ДополнитьСтроку()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ДобавитьКПрефиксу(Стр, Добавок="", Длина, Режим="Слева")
	                     
	ЧисловаяЧасть		=	"";
	Префикс			=	ВыделитьПрефикс(Стр, ЧисловаяЧасть);
	Если Режим="Слева" Тогда
		Результат	=	СокрЛП(Добавок) + Префикс;
	Иначе
		Результат	=	Префикс + СокрЛП(Добавок);
	КонецЕсли;

	Пока Длина - СтрДлина(Результат) - СтрДлина(ЧисловаяЧасть) > 0 Цикл
	    Результат	=	Результат + "0";
	КонецЦикла;
	Результат	=	Результат + Строка(ЧисловаяЧасть);
	
	Возврат(Результат);
	
	//Возврат ДополнитьНулями(НовыйПрефикс + ЧисловаяЧасть, Длина);

КонецФункции

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ВыполнитьПреобразование(СписокСтрокой, Знач Объект, Знач Реквизит="", ИдПравила="", Приемник_Длина=0)
	
	Если ПустоеЗначение(СписокСтрокой) = 1 Тогда Возврат("") КонецЕсли;
	
	Список	=	ЗначениеИзСтроки(СписокСтрокой);
	Если ТипЗначенияСтр(Список) <> "СписокЗначений" Тогда Возврат(СписокСтрокой) КонецЕсли;	//	Для простых строковых значений...

	Если Список.Получить("ОбъектИлиРеквизит") = "Реквизит" Тогда	Объект = Реквизит	КонецЕсли;

	Значение	=	Список.Получить("Значение");
	
	Если		Значение = "<Пустое значение>" Тогда
		Возврат("");
	ИначеЕсли	ПустоеЗначение(Значение) = 0 Тогда
		Значение	=	СтрЗаменить(Значение,	Симв(10),			"#рс#" );
		//Значение	=	СтрЗаменить(Значение,	СимволТабуляции,	"#ст#" );
		Возврат(Значение);
	КонецЕсли;
	
	СтрокаСумма	=	"";
	
	Для Сч = 1 По Список.РазмерСписка() Цикл
		
		Пред	=	"";
	    Зн		=	Список.ПолучитьЗначение(Сч, Пред);
		
		Если		Пред = "Атрибут"								Тогда
			
			Если Найти(Зн, "()") = 0 Тогда
				Если ТипЗначенияСтр(Объект) = "Справочник" Тогда
					Объект.ИспользоватьДату(ФормДатаКон, 1);
				КонецЕсли;
				Объект	=	Объект.ПолучитьАтрибут(Зн);
			Иначе
				Объект	=	ПолучитьЗначениеМетодом(Объект, Зн);
			КонецЕсли;
			
		ИначеЕсли	Пред = "ИтогПоКолонке"							Тогда
			
			Объект	=	Объект.Итог(Зн);
			                     
		ИначеЕсли	Пред = "Конкатенация"							Тогда
			
			Если Найти(Зн, "()") = 0 Тогда
				СтрокаСумма	=	СтрокаСумма	+	СокрЛ(ПолучитьИдОбъектаИсточника(Объект.ПолучитьАтрибут(Зн)));
			Иначе
				СтрокаСумма	=	СтрокаСумма	+	СокрЛ(ПолучитьИдОбъектаИсточника(ПолучитьЗначениеМетодом(Объект, Зн)));
			КонецЕсли;
			
		ИначеЕсли	Пред = "ДополнитьНулями"						Тогда

			Если Найти(Зн, "()") = 0 Тогда
				Объект	=	Объект.ПолучитьАтрибут(Зн);
			Иначе
				Объект	=	ПолучитьЗначениеМетодом(Объект, Зн);
			КонецЕсли;
			
			Объект	=	ДополнитьНулями(Объект, Приемник_Длина);
			                      
		ИначеЕсли	Пред = "ПолучитьИзПараметров"					Тогда
			
			Возврат("#ПолучитьИзПараметров");
			
		ИначеЕсли	Найти(Пред, "ИспользоватьСубконтоСчета") > 0	Тогда
			
			Правило	=	"";
			Счет	=	Объект.ПолучитьАтрибут(Зн);
			Если ПустоеЗначение(Счет)					= 1	Тогда	Возврат("")	КонецЕсли;
			Если НайтиПравило(Счет, Правило, ИдПравила)	= 0	Тогда	Возврат("")	КонецЕсли;
			    
			ИдПравила			=	"";
			УзелЗначения		=	Правило.ВыбратьУзел("Значение[@Источник=""" + Счет.Код + """]");
			Если ПустоеЗначение(УзелЗначения) = 1 Тогда	ЗаписатьОшибку("Не найдено правило конвертации значения " + Счет, "!"); Возврат("");	КонецЕсли;
			
			НомерСубконто		=	СокрЛП(СтрЗаменить(Пред, "ИспользоватьСубконтоСчета_", ""));
			
			Запрос				=	"Реквизит[(Приемник/@НомерСубконто = """ + НомерСубконто + """)]";
			АтрибутыЗначения	=	УзелЗначения.ВыбратьУзлы(Запрос);
			КоличествоУзлов		=	АтрибутыЗначения.КоличествоУзлов();
			Если ПустоеЗначение(КоличествоУзлов) = 1 Тогда Возврат("") КонецЕсли;
			     
			СписокВозможныхЗначений	=	Реквизит;
			
			Для СчАтрибутов = 0 По КоличествоУзлов - 1 Цикл
				АтрибутЗначения	=	АтрибутыЗначения.ПолучитьУзел(СчАтрибутов);
				                                                            
				Если (ПустоеЗначение(Реквизит) = 1) Или (Реквизит = "#Получить") Или (ТипЗначенияСтр(СписокВозможныхЗначений) = "СписокЗначений") Тогда
					РеквИсточник	=	АтрибутЗначения.ВыбратьУзел("Источник");
					Если ПустоеЗначение(РеквИсточник) = 0 Тогда
						ТипРеквИсточника		=	РеквИсточник.ПолучитьАтрибут("Тип");
						ВидРеквИсточника		=	РеквИсточник.ПолучитьАтрибут("Вид");
						НомерСубконтоИсточника	=	РеквИсточник.ПолучитьАтрибут("НомерСубконто");
						Если ТипЗначенияСтр(СписокВозможныхЗначений) = "СписокЗначений" Тогда
							Реквизит		=	ПодобратьЗначениеПоТипу(СписокВозможныхЗначений, ТипРеквИсточника, ВидРеквИсточника);
						Иначе
							Реквизит		=	ПодобратьЗначениеПоТипу(Объект, ТипРеквИсточника, ВидРеквИсточника, НомерСубконтоИсточника);
						КонецЕсли;
					КонецЕсли;
				КонецЕсли;
				                        
				Усл	=	АтрибутЗначения.ВыбратьУзел("Условия");
				Если ПустоеЗначение(Усл) = 0 Тогда
					Если УсловияВыполняются(Усл, Реквизит) = 0 Тогда Продолжить	КонецЕсли;
				КонецЕсли;
				
				ИдПравила	=	"";
				НайтиПравилоДляАтрибутаЗначения(Реквизит, , ИдПравила, АтрибутЗначения);
				Возврат(Реквизит);
			КонецЦикла;
			
		ИначеЕсли	Найти("ОбъектИлиРеквизит,Значение", Пред) > 0	Тогда
			
			Продолжить;
			
		КонецЕсли;
		
	КонецЦикла;
	
	Если ПустоеЗначение(СтрокаСумма) = 1 Тогда
		Возврат(Объект);
	Иначе
		Возврат(СтрокаСумма);
	КонецЕсли;
	
КонецФункции		//	ВыполнитьПреобразование()

//--------------------------------------------------------------------------------------------------
                                                                                           
Функция ПолучитьПараметрыПравила(СписокСтрокой, Знач Объект, Знач Реквизит="", СписокПараметровПравила="")

	СписокИсточник	=	ЗначениеИзСтроки(СписокСтрокой);
	Если ТипЗначенияСтр(СписокИсточник) <> "СписокЗначений" Тогда Возврат("") КонецЕсли;
	
	СписокПриемник	=	СоздатьОбъект("СписокЗначений");
    
	Для Сч = 1 По СписокИсточник.РазмерСписка() Цикл
		Атрибут		=	"";
		Значение	=	ВыполнитьПреобразование(СписокИсточник.ПолучитьЗначение(Сч, Атрибут), Объект, Реквизит);
		Если Значение = "#ПолучитьИзПараметров" Тогда
			Если ТипЗначенияСтр(СписокПараметровПравила) = "СписокЗначений" Тогда
				ЗначениеАтрибутаИзСписка = СписокПараметровПравила.Получить(Атрибут);
				Если ПустоеЗначение(ЗначениеАтрибутаИзСписка) = 0 Тогда
					СписокПриемник.ДобавитьЗначение(ЗначениеАтрибутаИзСписка, Атрибут);
				КонецЕсли;
			КонецЕсли;
		Иначе
			Если ПустоеЗначение(Значение) = 0 Тогда
				СписокПриемник.ДобавитьЗначение(Значение, Атрибут);
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;
	
	Возврат(СписокПриемник);
	
КонецФункции		//	ПолучитьПараметрыПравила()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ДобавитьРеквизит(Таб, Источник, Приемник="", Знач Зн="#Получить", Знач СпособЗагрузкиПоУмолчанию="", СписокДопПараметровПравила="")
	                                                       
	ИдПравилаРеквизитов		=	Таб.Ид;
	ВидУсловия				=	Таб.ВидУсловия;
	
	Если		ВидУсловия = 1 Тогда		//	условие задано по объекту
		Условия				=	Таб.Условия;
		Если УсловияВыполняются(Условия, Источник) = 0 Тогда Возврат("") КонецЕсли;
	ИначеЕсли	ВидУсловия = 2 Тогда			//	условие задано по значению реквизита
		Условия				=	Таб.Условия;
	КонецЕсли;
	
	
	ТипИсточника			=	ТипЗначенияСтр(Источник);
	
	Источник_Ид				=	Таб.Источник_Ид;
	Источник_Тип			=	Таб.Источник_Тип;
	Источник_ТипАтрибута	=	Таб.Источник_ТипАтрибута;
	
	Приемник_Ид				=	Таб.Приемник_Ид;
	Приемник_ТипАтрибута	=	Таб.Приемник_ТипАтрибута;
	Приемник_Тип			=	Таб.Приемник_Тип;
	Приемник_Вид			=	Таб.Приемник_Вид;
	Приемник_Длина			=	Таб.Приемник_Длина;
	
	Преобразование			=	Таб.Преобразование;
	ПравилоВыгрузки			=	Таб.Правило;
	
	ЕстьПроцедура			=	Таб.ЕстьПроцедура;
	ПараметрыПравила		=	Таб.ПараметрыПравила;
	ПолучитьИзПараметров	=	Таб.ПолучитьИзПараметров;
	
	СпособЗагрузки			=	Таб.СпособЗагрузки;
	                         
	
	//-------------------------------------------
	
	
    Если		(ТипИсточника = "Справочник") Или (ТипИсточника = "Счет")	Тогда
		
		ЭтоГруппа		=	Источник.ЭтоГруппа();
		Если (Найти(Источник_ТипАтрибута, "Э") > 0) И (ЭтоГруппа = 1)	Тогда	Возврат("")	КонецЕсли;
		Если (Найти(Приемник_ТипАтрибута, "Э") > 0) И (ЭтоГруппа = 1)	Тогда	Возврат("")	КонецЕсли;
		
		
		Если	(	(Найти(Источник_ТипАтрибута, "Г") > 0)		Или
					(Найти(Приемник_ТипАтрибута, "Г") > 0)	)	И	(ЭтоГруппа = 0) Тогда
			//	Проверим: не указано ли уже в xml-объекте что это все-таки группа
			Если ПустоеЗначение(Приемник.ПолучитьАтрибут("ЭтоГруппа")) = 1 Тогда
				УзелДляПроверки	=	Приемник.ВыбратьУзел("Ссылка");
				Если ПустоеЗначение(УзелДляПроверки) = 0 Тогда
					Если ПустоеЗначение(УзелДляПроверки.ПолучитьАтрибут("ЭтоГруппа")) = 1 Тогда
						Возврат("");
					КонецЕсли;
				Иначе
					Возврат("");	
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		
	ИначеЕсли	ТипИсточника = "Документ"		Тогда
		
		Если Источник_Ид = "ВремяДок" Тогда
			Зн	=	Источник.ПолучитьВремя();
		КонецЕсли;
		
	ИначеЕсли	ТипИсточника = "ЖурналРасчетов"	Тогда
		    
		ПервичнаяЗапись	=	Источник.ПервичнаяЗапись;	//	через две точки не работает!
		Если		Источник_Ид = "ДокументПервичнойЗаписи"		Тогда
			Если ПустоеЗначение(ПервичнаяЗапись) = 1 Тогда Возврат("") КонецЕсли;
			Зн	=	ПервичнаяЗапись.РодительскийДокумент;
			Если ПустоеЗначение(Зн) = 1 Тогда 	Возврат("") КонецЕсли;
		ИначеЕсли	Источник_Ид = "РегистрацияПервичнойЗаписи"	Тогда
			Если ПустоеЗначение(ПервичнаяЗапись) = 1 Тогда Возврат("") КонецЕсли;
			ПериодРегистрации	=	ПервичнаяЗапись.ПериодРегистрации;
			Зн					=	ПериодРегистрации.ДатаНачала;
		КонецЕсли;
		
	КонецЕсли;
    
	
	//-------------------------------------------
	           
	
	ПрерватьПослеОбработки	=	0;
	Если	ПустоеЗначение(ЕстьПроцедура) = 0 Тогда
		Зн	=	ДополнительныеПреобразования("ПравилоРеквизита", ИдПравилаРеквизитов, Источник, Приемник, СписокДопПараметровПравила);
		Если		Зн = 0 Тогда
			
			Возврат(0);
			
		ИначеЕсли	Зн = "#Прервать" Тогда
			
			Возврат("#Прервать");
			
		ИначеЕсли	Зн = "#ПрерватьПослеОбработки"	Тогда
			
			ЕстьПроцедура			=	0;
			ПрерватьПослеОбработки	=	1;
			
		ИначеЕсли	Зн = "#ПрерватьПереборСтрок"	Тогда
			
			Возврат("#ПрерватьПереборСтрок");
			
		КонецЕсли;
	КонецЕсли;
	                                             
	
	//-------------------------------------------
	
	
	ЗначениеИстории		=	"";
        
	Если	ПустоеЗначение(ЕстьПроцедура) = 1 Тогда
		
		Если		Источник_ТипАтрибута = "М"								Тогда
			Зн	=	ПолучитьЗначениеМетодом(Источник, Источник_Ид);
		ИначеЕсли	(Зн = "#Получить") И (ПустоеЗначение(Источник_Ид) = 0)	Тогда
			Если		(Найти("АО,РО", Источник_ТипАтрибута) > 0) И (ТипИсточника <> "Операция")	Тогда
				Зн		=	Источник.Операция.ПолучитьАтрибут(Источник_Ид);
			ИначеЕсли	Источник_ТипАтрибута = "ПК"	Тогда
				Врем	=	СоздатьОбъект("Периодический");
				Врем.ИспользоватьОбъект(Источник_Ид);
				Зн		=	Врем.ЗначениеНаДату( ?(ПустоеЗначение(ФормДатаКон)=1, РабочаяДата(), ФормДатаКон) );
			ИначеЕсли	Источник_ТипАтрибута = "К"	Тогда
				Зн		=	Константа.ПолучитьАтрибут(Источник_Ид);
			Иначе
				//Зн		=	Источник.ПолучитьАтрибут(Источник_Ид);
				
				//	Это помогает при отладке
				Попытка
					Зн		=	Источник.ПолучитьАтрибут(Источник_Ид);
				Исключение
				    Сообщить("Неверное имя реквизита! Объект:  " + Источник + ";   Реквизит:  " + Источник_Ид + ";   Правило реквизита:  " + ИдПравилаРеквизитов);
				КонецПопытки;
			КонецЕсли;
		ИначеЕсли	ТипЗначенияСтр(Зн) = "Периодический" Тогда
			ЗначениеИстории	=	Зн;
			Зн				=	ЗначениеИстории.Значение;
			ДатаЗначения	=	ЗначениеИстории.ДатаЗнач;
		ИначеЕсли	ПустоеЗначение(ПолучитьИзПараметров) = 0	Тогда
			Если ТипЗначенияСтр(СписокДопПараметровПравила) = "СписокЗначений" Тогда
				Зн			=	СписокДопПараметровПравила.Получить(Приемник_Ид);
			КонецЕсли;
		КонецЕсли;
		
	КонецЕсли;
	
	
	
	Если ВидУсловия = 2 Тогда	//	т.е. условие задано по значению реквизита
		Если УсловияВыполняются(Условия, Зн) = 0 Тогда Возврат("") КонецЕсли;
	КонецЕсли;
	
	
	
	Если		ПустоеЗначение(Преобразование) = 0	Тогда
		Зн	=	ВыполнитьПреобразование(Преобразование, Источник, Зн, ПравилоВыгрузки, Приемник_Длина);
	КонецЕсли;
	
	
	Если	Зн = "#Получить" Тогда	// значит это виртуальный объект (которого нет в базе источнике)
		Зн				=	"";
	//ИначеЕсли	Найти("Строка,Дата,Число", Приемник_Тип) > 0 Тогда
		// Хорошо бы здесь в таком случае сразу ПолучитьИдОбъектаИсточника()
	ИначеЕсли	(СпособЗагрузки				=	"ЗамещатьНеПустыми")	Или 
				((СпособЗагрузкиПоУмолчанию	=	"ЗамещатьНеПустыми")	И	(ПустоеЗначение(СпособЗагрузки) = 1))	Тогда
		Если ПустоеЗначение(Зн) = 1 Тогда	Возврат("")	КонецЕсли;
	КонецЕсли;

	
	Если	ПустоеЗначение(ПараметрыПравила) = 0	Тогда
		ПараметрыПравила = ПолучитьПараметрыПравила(ПараметрыПравила, Источник, Зн, СписокДопПараметровПравила);
	КонецЕсли;
	
	
	
	УзелСсылки				=	1;		// означает что нам нужна ссылка
	Значение				=	Выгрузить(Зн, ПравилоВыгрузки, УзелСсылки, ПараметрыПравила, Приемник_Тип, Приемник_Вид);
	
	
	
	Если		Приемник_ТипАтрибута = "М"			Тогда
		
		Если		Приемник_Ид = "ЭтоГруппа()"			Тогда
			УстановитьАтрибут(Приемник, "ЭтоГруппа", Значение);
			Возврат("");
		ИначеЕсли	Приемник_Ид = "СистемноеПредставление()"	Тогда
			
		Иначе
			Возврат(Значение);
		КонецЕсли;
		
	КонецЕсли;
	
    
	
	Если ПустоеЗначение(Приемник_Ид)	= 1	Тогда	Возврат(Значение)	КонецЕсли;
	Если ПустоеЗначение(Приемник)		= 1	Тогда	Возврат(Значение)	КонецЕсли;
	
	
	
	//-------------- xml --------------
	
	Если ПустоеЗначение(ЗначениеИстории) = 1 Тогда
		Если (Приемник_ТипАтрибута = "К") Или (Приемник_ТипАтрибута = "ПК") Тогда
		    Реквизит	=	Приемник;
		Иначе
			Реквизит	=	Приемник.СоздатьПодчиненныйЭлемент("Реквизит");
		КонецЕсли;
		УстановитьАтрибут(Реквизит,	"Идентификатор",	Приемник_Ид);
		УстановитьАтрибут(Реквизит,	"Значение", 		Значение);
		Если СпособЗагрузки <> "Поиск" Тогда
			УстановитьАтрибут(Реквизит,	"СпособЗагрузки",	СпособЗагрузки);
		КонецЕсли;
	Иначе
		Если СпособЗагрузки <> "Поиск" Тогда
			УстановитьАтрибут(Приемник,	"СпособЗагрузки",	СпособЗагрузки);
		КонецЕсли;
		Реквизит	=	Приемник.СоздатьПодчиненныйЭлемент("История");
		УстановитьАтрибут(Реквизит,	"Дата",			Выгрузить(ДатаЗначения));
		УстановитьАтрибут(Реквизит,	"Значение",		Значение);
	КонецЕсли;
	
	
	Если 		Найти("АО,РО", Приемник_ТипАтрибута) = 0	Тогда
	ИначеЕсли	ТипИсточника <> "Операция"					Тогда
		УстановитьАтрибут(Реквизит,	"ЭтоРеквизитОперации", "1");
	КонецЕсли;
	
        
	Если УзелСсылки <> 1 Тогда	// значит узел ссылки создан
		Реквизит.ДобавитьПодчиненный(УзелСсылки);
	КонецЕсли;
	
	
	Если	(Приемник_Тип	=	"Неопределенный")	Или
			((ПустоеЗначение(Приемник_Вид) = 1)		И	(Найти("Справочник,Документ,Перечисление,Счет", Приемник_Тип) > 0)) Тогда
				
		Если  ПустоеЗначение(ПравилоВыгрузки) = 1 Тогда
			Т	=	ТипЗначенияСтр(Зн);
			Если (ПустоеЗначение(Зн) = 1) И (Т = "Строка") Тогда
				Приемник.УдалитьПодчиненный(Реквизит);
			Иначе
				УстановитьАтрибут(Реквизит,	"ТипЗначения", 	Т);
			КонецЕсли;
		ИначеЕсли ПустоеЗначение(НайтиПравило(Зн, , ПравилоВыгрузки)) = 0 Тогда
			УстановитьАтрибут(Реквизит,	"ТипЗначения", 	гТабКэшПравил.Приемник_Тип);
			УстановитьАтрибут(Реквизит,	"ВидЗначения", 	гТабКэшПравил.Приемник_Вид);
		КонецЕсли;
	КонецЕсли;
	
	
	Если ПрерватьПослеОбработки = 1 Тогда
		Возврат("#Прервать");
	Иначе
		Возврат("");
	КонецЕсли;
	
КонецФункции		//	ДобавитьРеквизит()

//--------------------------------------------------------------------------------------------------
                                                                                 
Процедура ВыгрузитьОбъектСправочника(Источник, Приемник, ТабРеквизитов, ИдПравила, СпособЗагрузкиПоУмолчанию, ПараметрыПравила)
	    
	ТипИсточника	=	ТипЗначенияСтр(Источник);
	                                                                  
	ТабРеквизитов.ВыбратьСтроки();
	Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
	    ФлНеВыгружатьИсторию		=	1;
		СпособВыгрузки				=	ТабРеквизитов.СпособВыгрузки;
		
		Если ТипИсточника = "Справочник" Тогда
			ЭтоГруппа				=	Источник.ЭтоГруппа();
			
			Источник_ТипАтрибута	=	ТабРеквизитов.Источник_ТипАтрибута;
			Приемник_ТипАтрибута 	=	ТабРеквизитов.Приемник_ТипАтрибута;
		      
			Если 	(Найти(Источник_ТипАтрибута, "Э") > 0) И (ЭтоГруппа = 1)	Тогда Продолжить КонецЕсли;
			Если	(Найти(Источник_ТипАтрибута, "Г") > 0) И (ЭтоГруппа = 0)	Тогда Продолжить КонецЕсли;
			
			Если (СпособВыгрузки = "ВсюИсторию") Или (СпособВыгрузки = "ВсюИсториюРучную") Тогда
				Если (Лев(Источник_ТипАтрибута, 1)="П") И (Лев(Приемник_ТипАтрибута, 1)="П") Тогда
					ФлНеВыгружатьИсторию	=	0;
					Источник_Ид				=	ТабРеквизитов.Источник_Ид;
					Приемник_Ид				=	ТабРеквизитов.Приемник_Ид;
					История					=	СоздатьОбъект("Периодический");
					История.ИспользоватьОбъект(Источник_Ид, Источник);
					
					ДатаНачалаВыборки		=	ФормДатаНач;
					Если ПустоеЗначение(ФормДатаНач) = 0 Тогда
						История.ОбратныйПорядок(1);
						История.ВыбратьЗначения(, ФормДатаНач);
						Если История.ПолучитьЗначение() = 1 Тогда
							ДатаНачалаВыборки	=	История.ДатаЗнач;
						КонецЕсли;
					КонецЕсли;
					        
					
					История.ОбратныйПорядок(0);
					Если История.ВыбратьЗначения(ДатаНачалаВыборки, ФормДатаКон) = 0 Тогда Продолжить; КонецЕсли;
					РеквизитСИсторией	=	Приемник.СоздатьПодчиненныйЭлемент("Реквизит");
					УстановитьАтрибут(РеквизитСИсторией,	"Идентификатор", 	Приемник_Ид);
					Пока История.ПолучитьЗначение() = 1 Цикл
						Если СпособВыгрузки = "ВсюИсториюРучную" Тогда
							Если ПустоеЗначение(История.ТекущийДокумент()) = 0 Тогда Продолжить КонецЕсли;
						КонецЕсли;
						Результат = ДобавитьРеквизит(ТабРеквизитов, Источник, РеквизитСИсторией, История, СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
					КонецЦикла;
				КонецЕсли;
			КонецЕсли;		//	если способ выгрузки "Выгружать историю"
		КонецЕсли;
		
		Если ФлНеВыгружатьИсторию = 1 Тогда
			Результат = ДобавитьРеквизит(ТабРеквизитов, Источник, Приемник, "#Получить", СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
			Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
		КонецЕсли;
	КонецЦикла;		//	по правилам реквизитов
	
	ЗаписатьОбъектВФайл(Приемник);
	
КонецПроцедуры		//	ВыгрузитьОбъектСправочника()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Процедура ВыгрузитьКонстанты(ТабРеквизитов, ИдПравила)
                  
	ТабРеквизитов.ВыбратьСтроки();
	Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
		                  
		Источник_ТипАтрибута	=	ТабРеквизитов.Источник_ТипАтрибута;
		Приемник_ТипАтрибута 	=	ТабРеквизитов.Приемник_ТипАтрибута;
		      
		Источник_Ид				=	ТабРеквизитов.Источник_Ид;
		Приемник_Ид				=	ТабРеквизитов.Приемник_Ид;
		СпособВыгрузки			=	ТабРеквизитов.СпособВыгрузки;
		
		Если	ПустоеЗначение(Приемник_Ид) = 1		Тогда	Продолжить	КонецЕсли;
		
		XML_DOM					=	гXMLАнализатор.СоздатьДокумент();
		Приемник				=	XML_DOM.СоздатьУзел(1, "Константа");
		                   
		ИсточникПериодический	=	?(Лев(Источник_ТипАтрибута, 1)="П", 1, 0);
		ПриемникПериодический	=	?(Лев(Приемник_ТипАтрибута, 1)="П", 1, 0);
		
		Если	(ИсточникПериодический = 1) И (ПриемникПериодический = 1) И ( Найти(СпособВыгрузки, "ВсюИсторию")>0 ) Тогда
			История	=	СоздатьОбъект("Периодический");
			История.ИспользоватьОбъект(Источник_Ид);
			
			ДатаНачалаВыборки		=	ФормДатаНач;
			Если ПустоеЗначение(ФормДатаНач) = 0 Тогда
				История.ОбратныйПорядок(1);
				История.ВыбратьЗначения(, ФормДатаНач);
				Если История.ПолучитьЗначение() = 1 Тогда
					ДатаНачалаВыборки	=	История.ДатаЗнач;
				КонецЕсли;
			КонецЕсли;
			
			Если История.ВыбратьЗначения(ДатаНачалаВыборки, ФормДатаКон) = 0 Тогда Продолжить КонецЕсли;
			УстановитьАтрибут(Приемник,	"Идентификатор", 	Приемник_Ид);
			Пока История.ПолучитьЗначение() = 1 Цикл
				Если СпособВыгрузки = "ВсюИсториюРучную" Тогда
					Если ПустоеЗначение(История.ТекущийДокумент()) = 0 Тогда Продолжить КонецЕсли;
				КонецЕсли;
				Результат = ДобавитьРеквизит(ТабРеквизитов, Константа, Приемник, История);
			КонецЦикла;
		Иначе
			Результат = ДобавитьРеквизит(ТабРеквизитов, Константа, Приемник, "#Получить");
		КонецЕсли;
		Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
	
		ЗаписатьОбъектВФайл(Приемник);
		
	КонецЦикла;
	
КонецПроцедуры		//	ВыгрузитьКонстанты()

//--------------------------------------------------------------------------------------------------

Процедура ВыгрузитьКалендари(Правило, ИдПравила)

	Если (ПустоеЗначение(ФормДатаНач)=1) Или (ПустоеЗначение(ФормДатаКон) = 1) Тогда
		ЗаписатьОшибку("Для выгрузки календарей необходимо выбрать конкретный период!", "!");
		Возврат;
	КонецЕсли;
	
	Если ПустоеЗначение(Правило.ВыбратьУзел("Значение[@Источник = ""Праздники""]")) = 0 Тогда
		Праздники	=	СоздатьОбъект("Праздники");
		Если Праздники.ВыбратьДаты(ФормДатаНач, ФормДатаКон) = 1 Тогда
			XML_DOM					=	гXMLАнализатор.СоздатьДокумент();
			Приемник				=	XML_DOM.СоздатьУзел(1, "Календарь");
			УстановитьАтрибут(Приемник,	"Вид", 	"Праздники");
			Пока Праздники.СледующаяДата() = 1 Цикл
				День	=	Приемник.СоздатьПодчиненныйЭлемент("День");
				УстановитьАтрибут(День,	"Дата", 	Формат(Праздники.Дата, "ДДДММГГГГ") );
				УстановитьАтрибут(День,	"Значение",	Праздники.Значение);
			КонецЦикла;
			ЗаписатьОбъектВФайл(Приемник);
		КонецЕсли;
	КонецЕсли;    
	
	ВидыКалендарей	=	Правило.ВыбратьУзлы("Значение[@Источник != ""Праздники""]");
	Для Сч = 0 По ВидыКалендарей.КоличествоУзлов() - 1 Цикл
		ЭлКалендарь		=	ВидыКалендарей.ПолучитьУзел(Сч);
		ВидИсточника	=	ЭлКалендарь.ПолучитьАтрибут("Источник");
		ВидПриемника	=	ЭлКалендарь.ПолучитьАтрибут("Приемник");
		
		Календарь		=	СоздатьОбъект("Календарь." + ВидИсточника);
		Если Календарь.ВыбратьДаты(ФормДатаНач, ФормДатаКон) = 1 Тогда
			XML_DOM					=	гXMLАнализатор.СоздатьДокумент();
			Приемник				=	XML_DOM.СоздатьУзел(1, "Календарь");
			УстановитьАтрибут(Приемник,	"Вид", 					ВидПриемника);
			УстановитьАтрибут(Приемник,	"ДатаНачала",			Формат(ФормДатаНач, "ДДДММГГГГ") );
			УстановитьАтрибут(Приемник,	"ДатаОкончания",		Формат(ФормДатаКон, "ДДДММГГГГ") );
			УстановитьАтрибут(Приемник,	"УчитыватьПраздники",	1);
			Пока Календарь.СледующаяДата() = 1 Цикл
				День	=	Приемник.СоздатьПодчиненныйЭлемент("День");
				УстановитьАтрибут(День,	"Дата", 	Формат(Календарь.Дата, "ДДДММГГГГ") );
				УстановитьАтрибут(День,	"Значение",	Календарь.Значение);
			КонецЦикла;
			ЗаписатьОбъектВФайл(Приемник);
		КонецЕсли;
	КонецЦикла;
	
КонецПроцедуры		//	ВыгрузитьКалендари()

//--------------------------------------------------------------------------------------------------

Процедура ВыгрузитьДокумент(Источник, Приемник, ТабРеквизитов, ТабРеквизитовСтрок, ИдПравила, СпособЗагрузкиПоУмолчанию, ПараметрыПравила)
	
	//-----------------		Реквизиты	----------------------
	
	ТабРеквизитов.ВыбратьСтроки();
	Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
		Результат = ДобавитьРеквизит(ТабРеквизитов, Источник, Приемник, "#Получить", СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
		Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
	КонецЦикла;
	
	//-----------------		Строки	----------------------
	
	Если ТабРеквизитовСтрок.КоличествоСтрок() > 0 Тогда
		    
		СтрокиЕсть		=	0;
		Если ТипЗначенияСтр(Источник) = "Документ" Тогда
			СтрокиЕсть	=	Источник.ВыбратьСтроки();
		КонецЕсли;
		
		Если СтрокиЕсть = 1 Тогда
			Пока Источник.ПолучитьСтроку() = 1 Цикл
				Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
				ТабРеквизитовСтрок.ВыбратьСтроки();
				Пока ТабРеквизитовСтрок.ПолучитьСтроку() = 1 Цикл
					Результат = ДобавитьРеквизит(ТабРеквизитовСтрок, Источник, Эл_Строка, "#Получить", СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
					Если (Результат = "#Прервать") Или (Результат = "#ПрерватьПереборСтрок") Тогда Прервать КонецЕсли;
				КонецЦикла;
				Если Результат = "#ПрерватьПереборСтрок" Тогда Прервать КонецЕсли;
			КонецЦикла;
		Иначе
			ФлагСтрокиОписаныВПараметрах	=	0;
			Если ТипЗначенияСтр(ПараметрыПравила) = "СписокЗначений" Тогда
				Если ПустоеЗначение(ПараметрыПравила.Получить("#Строка")) = 0 Тогда
					ФлагСтрокиОписаныВПараметрах	=	1;
					НовыйСписок						=	СоздатьОбъект("СписокЗначений");
					Для СчПараметров = 1 По ПараметрыПравила.РазмерСписка() Цикл
						СтрРеквизит		=	"";
						ЗначРеквизита	=	ПараметрыПравила.ПолучитьЗначение(СчПараметров, СтрРеквизит);
						Если СтрРеквизит = "#Строка" Тогда Продолжить КонецЕсли;
						НовыйСписок.ДобавитьЗначение(ЗначРеквизита, СтрРеквизит);
					КонецЦикла;
				КонецЕсли;
			КонецЕсли;
			
			Если ФлагСтрокиОписаныВПараметрах = 1 Тогда
				Для СчПараметров = 1 По ПараметрыПравила.РазмерСписка() Цикл
					СтрРеквизит		=	"";
					ЗначРеквизита	=	ПараметрыПравила.ПолучитьЗначение(СчПараметров, СтрРеквизит);
					Если СтрРеквизит <> "#Строка" Тогда Продолжить КонецЕсли;
					ОкончательныйСписокПараметров	=	СоздатьОбъект("СписокЗначений");
					НовыйСписок.Выгрузить(ОкончательныйСписокПараметров);
					Для Ссс = 1 По ЗначРеквизита.РазмерСписка() Цикл
						СссСтр	=	"";
						СссЗн	=	ЗначРеквизита.ПолучитьЗначение(Ссс, СссСтр);
						ОкончательныйСписокПараметров.ДобавитьЗначение(СссЗн, СссСтр);
					КонецЦикла;
					Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
					ТабРеквизитовСтрок.ВыбратьСтроки();
					Пока ТабРеквизитовСтрок.ПолучитьСтроку() = 1 Цикл
						Результат = ДобавитьРеквизит(ТабРеквизитовСтрок, Источник, Эл_Строка, "#Получить", СпособЗагрузкиПоУмолчанию, ОкончательныйСписокПараметров);
						Если (Результат = "#Прервать") Или (Результат = "#ПрерватьПереборСтрок") Тогда Прервать КонецЕсли;
					КонецЦикла;
					Если Результат = "#ПрерватьПереборСтрок" Тогда Прервать КонецЕсли;
				КонецЦикла;
			Иначе
				//	для правил вида: "РШД -> РТД" (когда в источнике нет табличной части) - сливаем все в одну строку
				Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
				ТабРеквизитовСтрок.ВыбратьСтроки();
				Пока ТабРеквизитовСтрок.ПолучитьСтроку() = 1 Цикл
					Если ТабРеквизитовСтрок.Источник_ТипАтрибута = "РТД" Тогда Продолжить КонецЕсли; // м.б. в документе просто нет строк
					Результат = ДобавитьРеквизит(ТабРеквизитовСтрок, Источник, Эл_Строка, "#Получить", СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
					Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
				КонецЦикла;
			КонецЕсли;
		КонецЕсли;
		
	КонецЕсли;
	              
	ЗаписатьОбъектВФайл(Приемник);
	
КонецПроцедуры		//	ВыгрузитьДокумент()

//--------------------------------------------------------------------------------------------------

Функция ПолучитьИдОбъектаИсточника(Источник, ИдСинхронизирующегоРеквизита="")
    
	Если ПустоеЗначение(СокрЛП(Источник)) = 1 Тогда Возврат("") КонецЕсли;
	
	СтрИсточник		=	"";
	ТипИсточника	=	ТипЗначенияСтр(Источник);

	Если		ТипИсточника	= "Число" 			Тогда	СтрИсточник	=	Строка(Источник);
	ИначеЕсли	ТипИсточника	= "Строка" 			Тогда	СтрИсточник	=	СокрП(Источник);
	ИначеЕсли 	ТипИсточника	= "Дата" 			Тогда	СтрИсточник	=	Формат(Источник, "ДДДММГГГГ");
	
	ИначеЕсли 	ТипИсточника	= "Перечисление"	Тогда	СтрИсточник	=	Источник.Идентификатор();
		
	ИначеЕсли 	ТипИсточника	= "ПланСчетов" 		Тогда	СтрИсточник	=	Источник.Идентификатор();
	ИначеЕсли 	ТипИсточника	= "ВидСубконто"		Тогда	СтрИсточник	=	Источник.Идентификатор();
	ИначеЕсли 	ТипИсточника	= "Календарь" 		Тогда	СтрИсточник	=	Источник.Вид();
	ИначеЕсли 	ТипИсточника	= "ВидРасчета" 		Тогда	СтрИсточник	=	Источник.Код;
		
	ИначеЕсли 	ТипИсточника	= "Счет" 			Тогда	СтрИсточник	=	Источник.Код;
		
	ИначеЕсли 	ТипИсточника	= "Справочник"		Тогда
		
		Если ПустоеЗначение(ИдСинхронизирующегоРеквизита) = 1 Тогда ИдСинхронизирующегоРеквизита = "Наименование"	КонецЕсли;
		СтрИсточник	=	СокрЛП(Источник.ПолучитьАтрибут(ИдСинхронизирующегоРеквизита));
		
	ИначеЕсли 	ТипИсточника	= "Документ"		Тогда

		//Если ПустоеЗначение(ИдСинхронизирующегоРеквизита) = 1 Тогда ИдСинхронизирующегоРеквизита = "НомерДок"		КонецЕсли;
		//СтрИсточник	=	СокрЛП(Источник.ПолучитьАтрибут(ИдСинхронизирующегоРеквизита));
		
		СтрИсточник	=	СокрЛП(Источник);
	
	Иначе
		
		ЗаписатьОшибку("Неизвестный тип объекта:   " + ТипИсточника);
		
	КонецЕсли;
	          
	Возврат(СтрИсточник);
	
КонецФункции		//	ПолучитьИдОбъектаИсточника()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ВыгрузитьПоПравилу(Знач Источник="", Правило="", ИдПравила="", УзелСсылки=1, ПараметрыПравила="", Знач ТипПриемника="", Знач ВидПриемника="", НеСинхронизироватьПоДопПараметрам=0)
	  
	Перем	ТабРеквизитов;
	Перем	ТабРеквизитовПоиска;
	Перем	ТабРеквизитовСтрок;
	
	Если НайтиПравило(Источник, Правило, ИдПравила, ТипПриемника, ВидПриемника) = 0	Тогда	Возврат("")	КонецЕсли;

	
	ТипИсточника			=	ТипЗначенияСтр(Источник);
	Если (ТипПриемника = "") Или (ТипПриемника = "Неопределенный") Тогда
		ТипПриемника		=	гТабКэшПравил.Приемник_Тип;
	КонецЕсли;
	
	
	Преобразование			=	гТабКэшПравил.Преобразование;
	ПравилоПереадресации	=	гТабКэшПравил.ПравилоПереадресации;
	
	Если ПустоеЗначение(Преобразование)			= 0	Тогда	Источник =	ВыполнитьПреобразование(Преобразование, Источник)		КонецЕсли;
	Если ПустоеЗначение(ПравилоПереадресации)	= 0	Тогда	Возврат		Выгрузить(Источник, ПравилоПереадресации, УзелСсылки)	КонецЕсли;
	
	
	Если 		ТипПриемника	=	"Справочник"	Тогда	Тег	=	"ОбъектСправочника";
	ИначеЕсли 	ТипПриемника	=	"Документ"		Тогда	Тег	=	"Документ";
	ИначеЕсли 	ТипПриемника	=	"Константа"		Тогда
		гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
		ВыгрузитьКонстанты(ТабРеквизитов, ИдПравила);
		Возврат("");
	ИначеЕсли 	ПустоеЗначение(ТипПриемника) = 1	Тогда	//	???
		//Тег			=	ТипИсточника;
		Тег				=	"ОбъектСправочника";
		ТипПриемника	=	ТипИсточника;
	Иначе
	    //-------	Найдем идентифицирующее значение объекта ----------------
		
		ИдСинхронизирующегоРеквизита	=	гТабКэшПравил.ИдСинхронизирующегоРеквизита;
		ИдОбъектаИсточника				=	ПолучитьИдОбъектаИсточника(Источник, ИдСинхронизирующегоРеквизита);	// на пустое не проверяем специально
		//УзелЗначения					=	Правило.ВыбратьУзел("Значение[@Источник=""" + ИдОбъектаИсточника + """]");
		//Если ПустоеЗначение(УзелЗначения) = 0 Тогда Возврат(УзелЗначения.ПолучитьАтрибут("Приемник")) КонецЕсли;

		ВыборкаУзловЗначений			=	Правило.ВыбратьУзлы("Значение[@Источник=""" + ИдОбъектаИсточника + """]");
		КолвоУзлов						=	ВыборкаУзловЗначений.КоличествоУзлов();
		УзелНайден						=	0;
		Если		КолвоУзлов = 1 Тогда
			УзелНайден		=	1;
			УзелЗначения	=	ВыборкаУзловЗначений.ПолучитьУзел(0);
			//Возврат ВыборкаУзловЗначений.ПолучитьУзел(0).ПолучитьАтрибут("Приемник");
		ИначеЕсли	КолвоУзлов > 1 Тогда	//	в таком случае считаем что условия заданы обязательно
			Для Сч = 0 По КолвоУзлов - 1 Цикл
				УзелЗначения	=	ВыборкаУзловЗначений.ПолучитьУзел(Сч);
				Если УсловияВыполняются(УзелЗначения.ВыбратьУзел("Условия"), Источник) = 1 Тогда
					УзелНайден	=	1;
					Прервать;
					//Возврат УзелЗначения.ПолучитьАтрибут("Приемник");
				КонецЕсли;
			КонецЦикла;
		КонецЕсли;
		
		Если УзелНайден = 1 Тогда
			Если ПустоеЗначение(УзелЗначения.ПолучитьАтрибут("ЕстьПроцедура")) = 1 Тогда
				Возврат УзелЗначения.ПолучитьАтрибут("Приемник");
			Иначе
				ИдПравилаЗначения	=	УзелЗначения.ПолучитьАтрибут("Ид");
				Зн					=	ДополнительныеПреобразования("ПравилоЗначения", ИдПравилаЗначения, Источник, УзелЗначения.ПолучитьАтрибут("Приемник"));	// на всякий случай передадим туда значение приемника
				Возврат(Зн);
			КонецЕсли;
		КонецЕсли;
		   
		//	В значениях не нашли, тогда попробуем правила реквизитов посмотреть
		
		гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
		
        ТабРеквизитов.ВыбратьСтроки();
        Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
			Результат	=	ДобавитьРеквизит(ТабРеквизитов, Источник, , , , ПараметрыПравила);		//	обработка методов со стороны приемника
			Если ПустоеЗначение(Результат) = 0 Тогда	Возврат(Результат)	КонецЕсли;
        КонецЦикла;
		                                         
		Если		ПустоеЗначение(Преобразование) = 0		Тогда
			Возврат(Источник);
		ИначеЕсли	ПустоеЗначение(ИдОбъектаИсточника) = 0	Тогда
			ЗаписатьОшибку("Не найдено соответствие для значения источника:  " + ТипИсточника + "." + гТабКэшПравил.Источник_Вид + "." + ИдОбъектаИсточника,  "!");
		КонецЕсли;
		
		Возврат("");
	КонецЕсли;
    
	
	// если объект не виртуальный и источник пустой
	Если	(ПустоеЗначение(гТабКэшПравил.Источник_Тип) = 0)	И
			(ПустоеЗначение(СокрЛП(Источник)) = 1)				И
			(ПустоеЗначение(ПараметрыПравила) = 1)				Тогда	Возврат("") КонецЕсли;
	
	                                                         
	гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
	гТабКэшПравил.ТабРеквизитовПоиска.Выгрузить(ТабРеквизитовПоиска);
	гТабКэшПравил.ТабРеквизитовСтрок.Выгрузить(ТабРеквизитовСтрок);
	
	ПараметрыЗагрузки			=	гТабКэшПравил.ПараметрыЗагрузки;
	
	ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
	СтатусУдаления				=	гТабКэшПараметровЗагрузки.СтатусУдаления;
	СпособЗагрузкиПоУмолчанию	=	гТабКэшПараметровЗагрузки.СпособЗагрузки;
	НовыеНеСоздавать			=	гТабКэшПараметровЗагрузки.НовыеНеСоздавать;
	СтатусПроведения			=	гТабКэшПараметровЗагрузки.СтатусПроведения;
	
	
	Если ОбъектУжеВыгружен(Источник, ТабРеквизитовПоиска, ИдПравила, УзелСсылки, , ПараметрыПравила, НовыеНеСоздавать, НеСинхронизироватьПоДопПараметрам) = 1 Тогда Возврат("") КонецЕсли;
	
	
	Если ПустоеЗначение(Источник) = 0 Тогда
	    Если		ТипИсточника = "Справочник"	Тогда
			Источник.ИспользоватьДату(ФормДатаКон, 1);
		ИначеЕсли	ТипИсточника = "Счет"		Тогда
			Источник.ИспользоватьДату(ФормДатаКон);
		КонецЕсли;
	КонецЕсли;
	
	
	XML_DOM					=	гXMLАнализатор.СоздатьДокумент();
	Приемник				=	XML_DOM.СоздатьУзел(1, Тег);
	        
	Если (ПустоеЗначение(УзелСсылки) = 0) И (УзелСсылки <> 1) Тогда
		Приемник.ДобавитьПодчиненный(УзелСсылки);
		УзелСсылки	=	Приемник.ВыбратьУзел("Ссылка");
	КонецЕсли;
	
	
	УстановитьАтрибут(Приемник,	"Правило", ИдПравила);
	Если	(Найти("Справочник,Документ", ТипПриемника) > 0) И
			(Найти("Справочник,Документ", ТипИсточника) > 0) Тогда
		УстановитьАтрибут(Приемник,	"ПометитьНаУдаление",	ПометкаУдаления(Источник, СтатусУдаления));
	КонецЕсли;
	
	
	Если 		ТипПриемника	= "Справочник"		Тогда
		
	    Если		ТипИсточника = "Справочник"	Тогда
			УстановитьАтрибут(Приемник,	"ЭтоГруппа", Источник.ЭтоГруппа());
		ИначеЕсли	ТипИсточника = "Счет"		Тогда
			УстановитьАтрибут(Приемник,	"ЭтоГруппа", Источник.ЭтоГруппа());
		КонецЕсли;
		ВыгрузитьОбъектСправочника(Источник, Приемник, ТабРеквизитов, ИдПравила, СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
		
	ИначеЕсли 	ТипПриемника	= "Документ"		Тогда
		
		Если ТипИсточника = "Документ"	Тогда
			УстановитьАтрибут(Приемник,	"ОтменитьПроведение",	ОтменитьПроведение(Источник, СтатусПроведения));
		КонецЕсли;
		ВыгрузитьДокумент(Источник, Приемник, ТабРеквизитов, ТабРеквизитовСтрок, ИдПравила, СпособЗагрузкиПоУмолчанию, ПараметрыПравила);
		
	КонецЕсли;
    
	
	Возврат("");
	
КонецФункции		//	ВыгрузитьПоПравилу()
            
//--------------------------------------------------------------------------------------------------

Функция ВыгрузитьИтогиПоПравилу(Знач Источник="", Правило="", ИдПравила="", УзелСсылки=1)

	Перем	ТабРеквизитов;
	Перем	ТабРеквизитовПоиска;
	Перем	ТабРеквизитовСтрок;
	
	Если НайтиПравило(Источник, Правило, ИдПравила) = 0	Тогда	Возврат("")	КонецЕсли;
    
	ТипПриемника					=	гТабКэшПравил.Приемник_Тип;
	ТипИсточника					=	ТипЗначенияСтр(Источник);
	
	ПараметрыЗагрузки				=	гТабКэшПравил.ПараметрыЗагрузки;
	Преобразование					=	гТабКэшПравил.Преобразование;
	ПравилоПереадресации			=	гТабКэшПравил.ПравилоПереадресации;
	ИдСинхронизирующегоРеквизита	=	гТабКэшПравил.ИдСинхронизирующегоРеквизита;
	
	ВидУсловия						=	гТабКэшПравил.ВидУсловия;
	Условия							=	гТабКэшПравил.Условия;
	             
	
	гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
	гТабКэшПравил.ТабРеквизитовПоиска.Выгрузить(ТабРеквизитовПоиска);
	гТабКэшПравил.ТабРеквизитовСтрок.Выгрузить(ТабРеквизитовСтрок);
	
	
	XML_DOM							=	гXMLАнализатор.СоздатьДокумент();
	Приемник						=	XML_DOM.СоздатьУзел(1, "Документ");
	
	
	УзелСсылки						=	СоздатьУзелСсылки(Источник, ТабРеквизитовПоиска, "");
	Если (ПустоеЗначение(УзелСсылки) = 0) И (УзелСсылки <> 1) Тогда
		Приемник.ДобавитьПодчиненный(УзелСсылки);
		УзелСсылки	=	Приемник.ВыбратьУзел("Ссылка");
	КонецЕсли;
	
	
	ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
	СтатусУдаления				=	гТабКэшПараметровЗагрузки.СтатусУдаления;
	СпособЗагрузкиПоУмолчанию	=	гТабКэшПараметровЗагрузки.СпособЗагрузки;
	СтатусПроведения			=	гТабКэшПараметровЗагрузки.СтатусПроведения;

	УстановитьАтрибут(Приемник,	"Правило", 				ИдПравила);
	//УстановитьАтрибут(Приемник,	"ПометитьНаУдаление",	ПометкаУдаления(Источник, СтатусУдаления));
	//УстановитьАтрибут(Приемник,	"ОтменитьПроведение",	ОтменитьПроведение(Источник, гТабКэшПараметровЗагрузки.СтатусПроведения));
	
	//-----------------		Реквизиты	----------------------
	    
	ТабРеквизитов.ВыбратьСтроки();
	Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
		Результат = ДобавитьРеквизит(ТабРеквизитов, Источник, Приемник, "#Получить", СпособЗагрузкиПоУмолчанию);
		Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
	КонецЦикла;
	                              
	//-----------------		Строки	----------------------
	
	Если ТабРеквизитовСтрок.КоличествоСтрок() > 0 Тогда
		
		НомерСтроки = 1;
		
		Пока 1 = 1 Цикл
			                  
			Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
			ТабРеквизитовСтрок.ВыбратьСтроки();
			Пока ТабРеквизитовСтрок.ПолучитьСтроку() = 1 Цикл
				Результат = ДобавитьРеквизит(ТабРеквизитовСтрок, Источник, Эл_Строка, "#Получить", СпособЗагрузкиПоУмолчанию);
				Если Результат = "#Прервать" Тогда Прервать КонецЕсли;	//	Получить след. строку
			КонецЦикла;
			
			НомерСтроки = НомерСтроки+1;
			
			Если ФормМаксКолвоПроводок < НомерСтроки Тогда
				Прервать;
			ИначеЕсли Источник.ПолучитьИтог() = 0 Тогда
				Прервать;
			КонецЕсли;
			
			Если ВидУсловия = 1 Тогда	//	т.е. условие задано
				Пока УсловияВыполняются(Условия, Источник) = 0 Цикл
					ФлПрервать = 0;
					Если Источник.ПолучитьИтог() = 0 Тогда
						ФлПрервать = 1;
						Прервать;
					КонецЕсли;
				КонецЦикла;
				Если ФлПрервать = 1 Тогда Прервать КонецЕсли;
			КонецЕсли;
			
		КонецЦикла;
		
	КонецЕсли;
	
	
	ЗаписатьОбъектВФайл(Приемник);
	                 
	
	Если	(СтатусПроведения = "Провести")		И 
			(ПустоеЗначение(УзелСсылки) = 0)	И (УзелСсылки <> 1) Тогда
		XML_DOM						=	гXMLАнализатор.СоздатьДокумент();
		Приемник					=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
		Приемник.ДобавитьПодчиненный(УзелСсылки);
	    УстановитьАтрибут(Приемник,	"Правило", ИдПравила);
		ЗаписатьОбъектВФайл(Приемник);
	КонецЕсли;
	
              
	Возврат("");
	
КонецФункции		//	ВыгрузитьИтогиПоПравилу()

//--------------------------------------------------------------------------------------------------

Функция Выгрузить(Источник, ИдПравила="", УзелСсылки=0, ПараметрыПравила="", Знач ТипПриемника="", Знач ВидПриемника="")
	
	Если ПустоеЗначение(ИдПравила) = 0 Тогда
		Возврат	ВыгрузитьПоПравилу(Источник, , ИдПравила, УзелСсылки, ПараметрыПравила, ТипПриемника, ВидПриемника);
	КонецЕсли;
	
	
	Если (ПустоеЗначение(СокрЛП(Источник)) = 1) И (ТипПриемника <> "Неопределенный") Тогда
		Возврат("");
	КонецЕсли;
	
	
	ТипИсточника	=	ТипЗначенияСтр(Источник);
	
	Если		ПустоеЗначение(ТипПриемника) = 0	Тогда
		
		Если		Найти("Справочник,Документ,Счет,Неопределенный", ТипПриемника) = 0 Тогда
			Возврат	ПолучитьИдОбъектаИсточника(Источник);
		ИначеЕсли	(ТипПриемника = "Неопределенный") И (Найти("Справочник,Документ,Перечисление,Счет", ТипИсточника) = 0) Тогда
			Возврат	ПолучитьИдОбъектаИсточника(Источник);
		Иначе
			Возврат ВыгрузитьПоПравилу(Источник, , ИдПравила, УзелСсылки, ПараметрыПравила, ТипПриемника, ВидПриемника);
		КонецЕсли;
		
	ИначеЕсли	Найти("Справочник,Документ", ТипИсточника) = 0 Тогда
		
		Возврат	ПолучитьИдОбъектаИсточника(Источник);
		
	Иначе
		
		Возврат ВыгрузитьПоПравилу(Источник, , ИдПравила, УзелСсылки, ПараметрыПравила, ТипПриемника, ВидПриемника);
		
	КонецЕсли;
	
КонецФункции		//	Выгрузить()

//--------------------------------------------------------------------------------------------------

Функция ИнтерактивноЗаданныеОбъекты(Эл_Правило, ИдПравила, ИмяПравила)
    
	НомСтр			=	"";
	
	Если гТабОбъектов.НайтиЗначение(ИдПравила, НомСтр, "ИдПравила") = 1 Тогда
		СписокОбъектов	=	гТабОбъектов.ПолучитьЗначение(НомСтр, "СписокОбъектов");
		Если ПустоеЗначение(СписокОбъектов) = 0 Тогда
			Если гБезОткрытияФормы = 1 Тогда
				Сообщить("Обрабатывается правило:  " + ИмяПравила);
			Иначе
				ТабОбласть4.Текст	=	ИмяПравила;
				гКонт.Таблица.Показать();
			КонецЕсли;
		    Для СчОбъектов = 1 По СписокОбъектов.РазмерСписка() Цикл
				Объект	=	СписокОбъектов.ПолучитьЗначение(СчОбъектов);
				ВыгрузитьПоПравилу(Объект, Эл_Правило, ИдПравила);
		    КонецЦикла;
			Возврат(1);
		КонецЕсли;
	КонецЕсли;
	
	Возврат(0);
	
КонецФункции	//	ИнтерактивноЗаданныеОбъекты()

//--------------------------------------------------------------------------------------------------
                                                                                                     
Функция ВыгрузитьДанныеПоПравилу(Эл_Правило)
    
	ИдПравила				=	Эл_Правило.ПолучитьАтрибут("Ид");
	ИмяПравила				=	Эл_Правило.ПолучитьАтрибут("Имя");
	ПоСсылкам				=	Эл_Правило.ПолучитьАтрибут("ПоСсылкам");
	ЕстьПроцедураВыборки	=	Эл_Правило.ПолучитьАтрибут("ЕстьПроцедураВыборки");
	ИспользоватьВладельцев	=	Эл_Правило.ПолучитьАтрибут("ИспользоватьВладельцев");
    
	
	Если ИнтерактивноЗаданныеОбъекты(Эл_Правило, ИдПравила, ИмяПравила)	=	1	Тогда	Возврат(1)	КонецЕсли;
	Если ПустоеЗначение(Число(ПоСсылкам))								=	0	Тогда	Возврат(1)	КонецЕсли;	//	продолжаем перебор правил...
        
	
	Если ПустоеЗначение(ЕстьПроцедураВыборки) = 0 Тогда
	    Результат	=	ДополнительныеПреобразования("ПравилоВыборкиОбъектов", ИдПравила );
		Если Результат = "#Прервать" Тогда
			Предупреждение("Выгрузка данных прекращена согласно инструкции правила: '" + ИмяПравила + "' !");
			Возврат("Возврат");
		КонецЕсли;
	КонецЕсли;
                                                                           
	
	Если ФормФлВыгружатьТолькоИнтерактивные = 1 Тогда Возврат(1) КонецЕсли;
	
	
	Если гБезОткрытияФормы = 1 Тогда
		Сообщить("Обрабатывается правило:  " + ИмяПравила);
	Иначе
		ТабОбласть4.Текст	=	ИмяПравила;
		гКонт.Таблица.Показать();
	КонецЕсли;
	
	
	ЗагрузитьПравило(Эл_Правило, ИдПравила);
	
	Источник_Тип		=	гТабКэшПравил.Источник_Тип;
	Источник_Вид		=	гТабКэшПравил.Источник_Вид;
	
	Приемник_Тип		=	гТабКэшПравил.Приемник_Тип;
	Приемник_Вид		=	гТабКэшПравил.Приемник_Вид;
	
	
	
	Если ПустоеЗначение(ЕстьПроцедураВыборки) = 1 Тогда
		Если ПустоеЗначение(Источник_Тип) = 1 Тогда	//	возможно это виртуальный объект...
			ВыгрузитьПоПравилу(, Эл_Правило, ИдПравила);
			Возврат(1);
		КонецЕсли;
	КонецЕсли;
	
	
	//----	Выборки	-------------
	
	Если 			ПустоеЗначение(ЕстьПроцедураВыборки) = 0		Тогда
		
	ИначеЕсли		Источник_Тип	=	"Справочник"				Тогда
		    
		ОбъектВыгрузки = СоздатьОбъект("Справочник." + Источник_Вид);
		Если ПустоеЗначение(ИспользоватьВладельцев) = 1 Тогда
			ОбъектВыгрузки.ВыбратьЭлементы(0);
			Пока ОбъектВыгрузки.ПолучитьЭлемент() = 1 Цикл
				ВыгрузитьПоПравилу(ОбъектВыгрузки.ТекущийЭлемент(), Эл_Правило, ИдПравила);
			КонецЦикла;
		Иначе
			ИдВладельца			=	Метаданные.Справочник(Источник_Вид).Владелец.Идентификатор;
			Запрос				=	"//Правило[(ОбъектИсточник/@Тип = ""Справочник"")and(ОбъектИсточник/@Вид = """ + ИдВладельца + """)]";
			ПравилаВладельца	=	гПравила.ВыбратьУзлы(Запрос);
			Для Сч = 0 По ПравилаВладельца.КоличествоУзлов() - 1 Цикл
				ПравилоВладельца			=	ПравилаВладельца.ПолучитьУзел(Сч);
				ИдПравилаВладельца			=	ПравилоВладельца.ПолучитьАтрибут("Ид");
				//СписокВыгруженныхВладельцев	=	СписокСписковВыгруженныхОбъектов.Получить(ИдПравилаВладельца);
				НомСтр						=	"";
				Если ТабВыгруженныхОбъектов.НайтиЗначение(ИдПравилаВладельца, НомСтр, "ИдПравила") = 0 Тогда Продолжить КонецЕсли;
				ТабОбъектов	=	ТабВыгруженныхОбъектов.ПолучитьЗначение(НомСтр, "ТабОбъектов");
				//Если ТипЗначенияСтр(СписокВыгруженныхВладельцев) <> "СписокЗначений" Тогда Продолжить КонецЕсли;
				//Для СчВладельцев = 1 По СписокВыгруженныхВладельцев.РазмерСписка() Цикл
				ТабОбъектов.ВыбратьСтроки();
				Пока ТабОбъектов.ПолучитьСтроку() = 1 Цикл
					//СистПредставлениеВладельца	=	"";
					//СписокВыгруженныхВладельцев.ПолучитьЗначение(СчВладельцев, СистПредставлениеВладельца);
					СистПредставлениеВладельца	=	ТабОбъектов.Объект;
					Если Найти(СистПредставлениеВладельца, "}") > 0 Тогда
						ОтделитьРазделителем(СистПредставлениеВладельца, "}", 1);
					    ЭлементВладелец	=	ЗначениеИзСтрокиВнутр(СистПредставлениеВладельца);
					Иначе
						ЭлементВладелец	=	СистПредставлениеВладельца;
					КонецЕсли;
					ОбъектВыгрузки.ИспользоватьВладельца(ЭлементВладелец);
					ОбъектВыгрузки.ВыбратьЭлементы(1);
					Пока ОбъектВыгрузки.ПолучитьЭлемент() = 1 Цикл
						ВыгрузитьПоПравилу(ОбъектВыгрузки.ТекущийЭлемент(), Эл_Правило, ИдПравила);
					КонецЦикла;
				КонецЦикла;
			КонецЦикла;
		КонецЕсли;
		
	ИначеЕсли		Источник_Тип	=	"Документ"					Тогда
		
		ОбъектВыгрузки	=	СоздатьОбъект("Документ." + Источник_Вид);
		ОбъектВыгрузки.ВыбратьДокументы(ФормДатаНач, ФормДатаКон);
		Пока ОбъектВыгрузки.ПолучитьДокумент() = 1 Цикл
			ВыгрузитьПоПравилу(ОбъектВыгрузки.ТекущийДокумент(), Эл_Правило, ИдПравила);
		КонецЦикла;
	
	ИначеЕсли		Источник_Тип	=	"Регистр"					Тогда
		                           
		ОбъектВыгрузки	=	СоздатьОбъект("Регистр." + Источник_Вид);
		
		ОбъектВыгрузки.ВременныйРасчет(1);
		РассчитатьРегистрыПо(ПолучитьПозициюТА());
		ОбъектВыгрузки.ВыбратьИтоги();
		Пока ОбъектВыгрузки.ПолучитьИтог() = 1 Цикл
			ВыгрузитьИтогиПоПравилу(ОбъектВыгрузки, Эл_Правило, ИдПравила);
		КонецЦикла;
		
	ИначеЕсли		Источник_Тип	=	"Счет"						Тогда

		ОбъектВыгрузки = СоздатьОбъект("Счет." + Источник_Вид);
		ОбъектВыгрузки.ВыбратьСчета();
		Пока ОбъектВыгрузки.ПолучитьСчет() = 1 Цикл
			ВыгрузитьПоПравилу(ОбъектВыгрузки.ТекущийСчет(), Эл_Правило, ИдПравила);
		КонецЦикла;

	ИначеЕсли		Источник_Тип	=	"Константа"					Тогда
		
		ВыгрузитьПоПравилу(, Эл_Правило, ИдПравила);
		
	ИначеЕсли		Источник_Тип	=	"Календарь"					Тогда
		
		ВыгрузитьКалендари(Эл_Правило, ИдПравила);
		
	ИначеЕсли		Источник_Тип	=	"Операция"					Тогда
	ИначеЕсли		Источник_Тип	=	"ВидСубконто"				Тогда
		
		Для СчВидовСубконто = 1 По ВидыСубконто.КоличествоЗначений() Цикл
			ВыгрузитьПоПравилу(ВидыСубконто.ЗначениеПоНомеру(СчВидовСубконто), Эл_Правило, ИдПравила);
		КонецЦикла;
		
	ИначеЕсли		Источник_Тип	=	"Перечисление"				Тогда
		                                  
		ВидПеречисления	=	Перечисление.ПолучитьАтрибут(Источник_Вид);
		Для СчЗначенийПеречисления = 1 По ВидПеречисления.КоличествоЗначений() Цикл
			ВыгрузитьПоПравилу(ВидПеречисления.ЗначениеПоНомеру(СчЗначенийПеречисления), Эл_Правило, ИдПравила);
		КонецЦикла;
		
	ИначеЕсли		Источник_Тип	=	"ПланСчетов"				Тогда	
	ИначеЕсли		Источник_Тип	=	"ВидРасчета"				Тогда
	ИначеЕсли		Источник_Тип	=	"ЖурналРасчетов"			Тогда
	КонецЕсли;

	
	//	над этим еще нужно поработать...
	
	//гСписокОбработанныхПравил.ДобавитьЗначение(ИдПравила);
	//Поз	=	гСписокНеобработанныхПравил.НайтиЗначение(ИдПравила);
	//Если ПустоеЗначение(Поз) = 0 Тогда
	//	гСписокНеобработанныхПравил.УдалитьЗначение(Поз);
	//КонецЕсли;
	
	//Если ФормФлЗапоминатьСсылки = 0 Тогда
	//	СписокВыгруженныхОбъектов	=	СписокСписковВыгруженныхОбъектов.Получить(ИдПравила);
	//	Поз							=	СписокСписковВыгруженныхОбъектов.НайтиЗначение(СписокВыгруженныхОбъектов);
	//	Если ПустоеЗначение(Поз) = 0 Тогда
	//		СписокСписковВыгруженныхОбъектов.УдалитьЗначение(Поз);
	//	КонецЕсли;
	//КонецЕсли;
	
	
	Возврат(1);
	
КонецФункции		//	ВыгрузитьДанныеПоПравилу()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ПодготовитьТаблицуДляПроведения()
	
	гТабКэшПравил.НоваяКолонка("Порядок", "Строка");
	гТабКэшПравил.ВыбратьСтроки();
	Пока гТабКэшПравил.ПолучитьСтроку() = 1 Цикл
		Ид						=	гТабКэшПравил.Ид;
		Приемник_Вид			=	гТабКэшПравил.Приемник_Вид;
		гТабКэшПравил.Порядок	=	СтрЗаменить(Ид, Приемник_Вид + "_", "");
	КонецЦикла;
	
	
	гТабКэшПравил.Сортировать("Источник_Тип + , Источник_Вид + , Порядок +");
	              
	
	гТабКэшПравил.УдалитьКолонку("Порядок");
	
	
	КопияТабПравил	=	СоздатьОбъект("ТаблицаЗначений");
	гТабКэшПравил.Выгрузить(КопияТабПравил);
	
	
	ТабВидовДокументов	=	СоздатьОбъект("ТаблицаЗначений");
	ТабВидовДокументов.НоваяКолонка("ВидДокумента", "Строка");
	ТабВидовДокументов.НоваяКолонка("СписокПравил",	"СписокЗначений");	//	(НомерСтроки таблицы правил, ИдПравила)
	
	
	гТабКэшПравил.ВыбратьСтроки();
	Пока гТабКэшПравил.ПолучитьСтроку() = 1 Цикл
		Если гТабКэшПравил.Источник_Тип <> "Документ" Тогда Продолжить КонецЕсли;
		                                         
		ВидДокумента			=	гТабКэшПравил.Источник_Вид;
		ИдПравила				=	гТабКэшПравил.Ид;
		ПравилоПереадресации	=	гТабКэшПравил.ПравилоПереадресации;
		НомСтр					=	"";
		
		Если ТабВидовДокументов.НайтиЗначение(ВидДокумента, НомСтр, "ВидДокумента") = 0 Тогда
			ТабВидовДокументов.НоваяСтрока(1);
			ТабВидовДокументов.ВидДокумента	=	ВидДокумента;
			ТабВидовДокументов.СписокПравил	=	СоздатьОбъект("СписокЗначений");
		Иначе
			ТабВидовДокументов.ПолучитьСтрокуПоНомеру(НомСтр);
		КонецЕсли;
		ТабВидовДокументов.СписокПравил.ДобавитьЗначение(гТабКэшПравил.НомерСтроки, ИдПравила);
		        
		
		Если ПустоеЗначение(ПравилоПереадресации) = 0 Тогда
			НомПравилаПереадр	=	"";
			Если  КопияТабПравил.НайтиЗначение(ПравилоПереадресации, НомПравилаПереадр, "Ид") = 1 Тогда
				ТабВидовДокументов.СписокПравил.ДобавитьЗначение(НомПравилаПереадр, ПравилоПереадресации);
			КонецЕсли;
		КонецЕсли;                    
		
		
	КонецЦикла;
	
	Возврат(ТабВидовДокументов);
	
КонецФункции		//	ПодготовитьТаблицуДляПроведения()

//--------------------------------------------------------------------------------------------------

Функция ПолучитьЗначениеКолонки(Таб, ИдКолонкиПоиска, ЗнПоиска, ИдКолонкиВозврата)

	НомСтр = "";
	Если Таб.НайтиЗначение(ЗнПоиска, НомСтр, ИдКолонкиПоиска) = 0 Тогда
		Возврат "";
	Иначе
		Возврат Таб.ПолучитьЗначение(НомСтр, ИдКолонкиВозврата);
	КонецЕсли;
	
КонецФункции

//--------------------------------------------------------------------------------------------------
                                                                                                    
Процедура УстановитьПериоды(Док, Приемник, ИдПравилаДок="")
	
	Для СчЖурналов = 1 По Метаданные.ЖурналРасчетов() Цикл
		
		ВидЖР	=	Метаданные.ЖурналРасчетов(СчЖурналов).Идентификатор;
		ЖР		=	СоздатьОбъект( "ЖурналРасчетов." + ВидЖР);
		Правило	=	"";
		
		Если ЖР.ВыбратьЗаписиПоДокументу(Док)	=	0	Тогда	Продолжить	КонецЕсли;
		Если НайтиПравило(ЖР, Правило, , , , ИдПравилаДок)			=	0	Тогда	Продолжить	КонецЕсли;
		                               
		ПараметрыЗагрузки	=	гТабКэшПравил.ПараметрыЗагрузки;
		ВидЖРПриемника		=	гТабКэшПравил.Приемник_Вид;
		
		ЖР.ПолучитьЗапись();
		
		//	установим период 
		
		ВПериодеЖР			=	Приемник.СоздатьПодчиненныйЭлемент("ВПериодеЖР");
		УстановитьАтрибут(ВПериодеЖР,	"ВидЖР", 	ВидЖРПриемника);
		УстановитьАтрибут(ВПериодеЖР,	"Дата", 	Формат(ЖР.ПериодРегистрации.ДатаНачала, "ДДДММГГГГ") );
		                                                           
	КонецЦикла;		//	по журналам расчетов
	
КонецПроцедуры		//	УстановитьПериоды()

//--------------------------------------------------------------------------------------------------

Процедура ВыгрузитьЗаписи(Док, ИдПравилаДок, УзелСсылки)
	    
	Перем	ТабРеквизитов;
	Перем	Приемник;
	
	Для СчЖурналов = 1 По Метаданные.ЖурналРасчетов() Цикл
		
		ВидЖР	=	Метаданные.ЖурналРасчетов(СчЖурналов).Идентификатор;
		ЖР		=	СоздатьОбъект( "ЖурналРасчетов." + ВидЖР);
		
		Если ЖР.ВыбратьЗаписиПоДокументу(Док.ТекущийДокумент())	= 0 Тогда Продолжить КонецЕсли;
		
		Если ПустоеЗначение(Приемник) = 1 Тогда
			XML_DOM				=	гXMLАнализатор.СоздатьДокумент();
			Приемник			=	XML_DOM.СоздатьУзел(1, "ЗаписиЖРДокумента");
			Приемник.УстановитьАтрибут("Правило", ИдПравилаДок);
			Приемник.ДобавитьПодчиненный(УзелСсылки);
		КонецЕсли;
		        
		//ФлПрервать			=	ЖР.ПолучитьЗапись();
		//Правило	=	"";
		//Если НайтиПравило(ЖР, Правило) = 0 Тогда Продолжить КонецЕсли;
		//ПараметрыЗагрузки	=	гТабКэшПравил.ПараметрыЗагрузки;
		//ВидЖРПриемника		=	гТабКэшПравил.Приемник_Вид;
		//гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
		
		Состояние("Выгружаются записи журнала расчетов '" + ВидЖР + "' по документу:  " + Док);
		
		//ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
		//СпособЗагрузкиПоУмолчанию	=	гТабКэшПараметровЗагрузки.СпособЗагрузки;
		                                                                         
		СпособЗагрузкиПоУмолчанию	=	"";
		
		СчЗаписей	=	1;
		
		Пока ЖР.ПолучитьЗапись() = 1 Цикл
			Правило = "";
			Если НайтиПравило(ЖР, Правило, , , , ИдПравилаДок) = 0 Тогда Продолжить КонецЕсли;
			//ПараметрыЗагрузки	=	гТабКэшПравил.ПараметрыЗагрузки;
			ВидЖРПриемника		=	гТабКэшПравил.Приемник_Вид;
			гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
			
			ЗаписьЖР = Приемник.СоздатьПодчиненныйЭлемент("ЗаписьЖР");
			УстановитьАтрибут(ЗаписьЖР,	"ВидЖР", 	ВидЖРПриемника);
			УстановитьАтрибут(ЗаписьЖР,	"Дата", 	Формат(ЖР.ПериодРегистрации.ДатаНачала, "ДДДММГГГГ") );
			    
			ТабРеквизитов.ВыбратьСтроки();
			Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
				Результат = ДобавитьРеквизит(ТабРеквизитов, ЖР, ЗаписьЖР, "#Получить", СпособЗагрузкиПоУмолчанию);
				Если Результат = "#Прервать" Тогда Прервать КонецЕсли;	//	Получить след. запись
			КонецЦикла;
			
			Если ПустоеЗначение(ЗаписьЖР.ВыбратьУзел("Реквизит[@Идентификатор = ""ВидРасч""]")) = 1 Тогда
				Приемник.УдалитьПодчиненный(ЗаписьЖР);	//	если не указан вид расчета
			КонецЕсли;
			
			СчЗаписей	=	СчЗаписей + 1;
			Если СчЗаписей % 10 = 0 Тогда
				Состояние("Выгружаются записи ЖР '" + ВидЖР + "' по документу: " + Док + "   Выгружено: " + СчЗаписей);
			КонецЕсли;
		КонецЦикла;		//	по записям
		
	КонецЦикла;			//	по журналам расчетов
	            
	
	Если ПустоеЗначение(Приемник) = 0 Тогда
		ЗаписатьОбъектВФайл(Приемник);
	КонецЕсли;
	
КонецПроцедуры		//	ВыгрузитьЗаписи()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция СоздатьНовуюПроводку(Узел, СчетДт="", СчетКт="", Сумма="", Колво="", Валюта="", ВалСумма="", СодержаниеПроводки="", НомерЖурнала="", ИдПланаСчетов="")
                                 
	Если Узел.ИмяТэга = "Проводка" Тогда
		УзелОперации =	Узел.Родитель;
		УзелОперации.УдалитьПодчиненный(Узел);	// удаляем  проводку созданную автоматически
		Узел = УзелОперации;
	КонецЕсли;
	                        
	
	УзелПроводки = Узел.СоздатьПодчиненныйЭлемент("Проводка");
	
	
	Если ПустоеЗначение(СчетДт) = 0 Тогда
		УзелПроводки.УстановитьАтрибут("СчетДт",		СчетДт);
	КонецЕсли;
	
	Если ПустоеЗначение(СчетКт) = 0 Тогда
		УзелПроводки.УстановитьАтрибут("СчетКт",		СчетКт);
	КонецЕсли;
	
	Если ПустоеЗначение(ИдПланаСчетов) = 0 Тогда
		УзелПроводки.УстановитьАтрибут("ПланСчетов",	ИдПланаСчетов);
	КонецЕсли;
	
	                                                             
	Если ПустоеЗначение(Сумма) = 0 Тогда
		РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
		РеквизитПроводки.УстановитьАтрибут("Идентификатор", "Сумма");
		РеквизитПроводки.УстановитьАтрибут("Значение",		 Сумма);
	КонецЕсли;
	
	Если ПустоеЗначение(ВалСумма) = 0 Тогда
		РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
		РеквизитПроводки.УстановитьАтрибут("Идентификатор", "ВалСумма");
		РеквизитПроводки.УстановитьАтрибут("Значение",		 ВалСумма);
	КонецЕсли;
	
	Если ПустоеЗначение(Колво) = 0 Тогда
		РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
		РеквизитПроводки.УстановитьАтрибут("Идентификатор", "Количество");
		РеквизитПроводки.УстановитьАтрибут("Значение",		 Колво);
	КонецЕсли;
	
	Если ПустоеЗначение(СодержаниеПроводки) = 0 Тогда
		РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
		РеквизитПроводки.УстановитьАтрибут("Идентификатор", "СодержаниеПроводки");
		РеквизитПроводки.УстановитьАтрибут("Значение",		 СодержаниеПроводки);
	КонецЕсли;
	
	Если ПустоеЗначение(НомерЖурнала) = 0 Тогда
		РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
		РеквизитПроводки.УстановитьАтрибут("Идентификатор", "НомерЖурнала");
		РеквизитПроводки.УстановитьАтрибут("Значение",		 НомерЖурнала);
	КонецЕсли;
	
	Если ПустоеЗначение(Валюта) = 0 Тогда
		УзелСсылки			=	1;
		Значение			=	Выгрузить(Валюта, , УзелСсылки);
		Если УзелСсылки <> 1 Тогда
			РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
			РеквизитПроводки.УстановитьАтрибут("Идентификатор", "Валюта");
			РеквизитПроводки.ДобавитьПодчиненный(УзелСсылки);
		КонецЕсли;
	КонецЕсли;
	
	Возврат(УзелПроводки);
	
КонецФункции		//	СоздатьНовуюПроводку()

//--------------------------------------------------------------------------------------------------
       
Функция ДобавитьЗначениеСубконто(Правило, Операция, УзелПроводки="", УзелОперации="", ДтИлиКт, Знач Зн="#Получить")
	
	ИдПравилаРеквизитов	=	"";
	ЗагрузитьПравилоРеквизитовЗначения(Правило, ИдПравилаРеквизитов);
	
	Источник_Ид				=	гТабКэшРеквизитовЗначений.Источник_Ид;
	
	Приемник_Ид				=	гТабКэшРеквизитовЗначений.Приемник_Ид;
	Приемник_Тип			=	гТабКэшРеквизитовЗначений.Приемник_Тип;
	Приемник_Вид			=	гТабКэшРеквизитовЗначений.Приемник_Вид;
	Приемник_Длина			=	гТабКэшРеквизитовЗначений.Приемник_Длина;
	
	//Условия				=	гТабКэшРеквизитовЗначений.Условия;
	ВидУсловия				=	гТабКэшРеквизитовЗначений.ВидУсловия;
	
	ЕстьПроцедура			=	гТабКэшРеквизитовЗначений.ЕстьПроцедура;
	
	ПараметрыПравила		=	гТабКэшРеквизитовЗначений.ПараметрыПравила;
	
	Преобразование			=	гТабКэшРеквизитовЗначений.Преобразование;
	ПравилоВыгрузки			=	гТабКэшРеквизитовЗначений.Правило;


	
	Если (ДтИлиКт = "Дт") И (Зн = "#Получить") Тогда
		Источник = Операция.Дебет;
	Иначе
		Источник = Операция.Кредит;
	КонецЕсли;
	
	                                             
	Если	(Зн = "#Получить") И (ПустоеЗначение(Источник_Ид) = 0)	Тогда
		Зн	=	Источник.Субконто(ВидыСубконто.ЗначениеПоИдентификатору(Источник_Ид));
		Если ТипЗначенияСтр(Зн) = "Справочник" Тогда
			Зн.ИспользоватьДату(ФормДатаКон, 1);
		КонецЕсли;
	КонецЕсли;

	
	Если ВидУсловия = 1 Тогда
		Условия	=	гТабКэшРеквизитовЗначений.Условия;
		Если УсловияВыполняются(Условия, Зн) = 0 Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	
    СписокДопПараметровПравила	=	"";
	Если ПустоеЗначение(ЕстьПроцедура) = 0 Тогда
		СписокДопПараметровПравила	=	СоздатьОбъект("СписокЗначений");
		Зн	=	ДополнительныеПреобразования("ПравилоРеквизитаЗначения", ИдПравилаРеквизитов, Операция, УзелПроводки, СписокДопПараметровПравила);
		Если		Зн = 0 Тогда
			Возврат(0);
		ИначеЕсли	Зн = "#Прервать" Тогда
			Возврат("#Прервать");	//	Не обрабатывать остальные правила субконто
		КонецЕсли;
	КонецЕсли;
	
	
	Если		ПустоеЗначение(Преобразование) = 0	Тогда
		Зн	=	ВыполнитьПреобразование(Преобразование, Зн, Зн, ПравилоВыгрузки, Приемник_Длина);
	ИначеЕсли	Зн = "#Получить" Тогда	// значит это виртуальный объект (которого нет в базе источнике)
		Зн				=	"";
	КонецЕсли;
	
	//Если ПустоеЗначение(ПравилоВыгрузки) = 1 Тогда
	//	Если НайтиПравилоДляАтрибутаЗначения(Зн, , ПравилоВыгрузки, Правило) = 0 Тогда	Возврат(0)	КонецЕсли;
	//КонецЕсли;

	
	Если	ПустоеЗначение(ПараметрыПравила) = 0	Тогда
		ПараметрыПравила = ПолучитьПараметрыПравила(ПараметрыПравила, Операция, Зн, СписокДопПараметровПравила);
	КонецЕсли;
	
	
	
	УзелСсылки				=	1;		// означает что нам нужна ссылка
	Значение				=	Выгрузить(Зн, ПравилоВыгрузки, УзелСсылки, ПараметрыПравила, Приемник_Тип, Приемник_Вид);
	
	
	Если ПустоеЗначение(УзелПроводки)	= 1 Тогда Возврат(0) КонецЕсли;
	Если ПустоеЗначение(Приемник_Ид)	= 1 Тогда Возврат(0) КонецЕсли;
	
	//-------------- xml --------------
	
	Реквизит	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Субконто" + ДтИлиКт);
	УстановитьАтрибут(Реквизит,	"Идентификатор",	Приемник_Ид);
	
	Если УзелСсылки <> 1 Тогда	// значит узел ссылки создан
		Реквизит.ДобавитьПодчиненный(УзелСсылки);
	Иначе
		УстановитьАтрибут(Реквизит,	"Значение", 	Значение);
	КонецЕсли;
	
	Если	(ПустоеЗначение(Приемник_Вид) = 1) И ( Найти("Справочник,Документ,Счет", Приемник_Тип) > 0 )	Тогда
		Если ПустоеЗначение(НайтиПравило(Зн, , ПравилоВыгрузки)) = 0 Тогда
			УстановитьАтрибут(Реквизит,	"ВидЗначения", 	гТабКэшПравил.Приемник_Вид);
		КонецЕсли;
	КонецЕсли;
	
КонецФункции		//	ДобавитьЗначениеСубконто()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ВыгрузитьКорреспонденцию(Операция, Счет, ДтИлиКт, УзелПроводки, УзелОперации, Знач ИдПравила="")

	Если ПустоеЗначение(Счет) = 1 Тогда Возврат(1) КонецЕсли;
	
	Если ДтИлиКт = "Дт" Тогда
		Корреспонденция = Операция.Дебет;
	Иначе
		Корреспонденция = Операция.Кредит;
	КонецЕсли;

	Правило	=	"";
	Если НайтиПравило(Счет, Правило, ИдПравила)	= 0	Тогда	Возврат(0)	КонецЕсли;
	
	//	Если счет задан вручную, то ищем правило по приемнику
	ИдСчета				=	ПолучитьИдОбъектаИсточника(Счет);
	Запрос				=	"Значение[@" + ?(ТипЗначенияСтр(Счет)="Счет", "Источник", "Приемник") + "=""" + ИдСчета + """]";
	//УзелЗначения		=	Правило.ВыбратьУзел(Запрос);
	
	ВыборкаУзловЗначений	=	Правило.ВыбратьУзлы(Запрос);
	КолвоУзлов				=	ВыборкаУзловЗначений.КоличествоУзлов();
	УзелНайден				=	0;
	Если		КолвоУзлов = 1 Тогда
		УзелНайден		=	1;
		УзелЗначения	=	ВыборкаУзловЗначений.ПолучитьУзел(0);
	ИначеЕсли	КолвоУзлов > 1 Тогда	//	в таком случае считаем что условия заданы обязательно
		Для Сч = 0 По КолвоУзлов - 1 Цикл
			УзелЗначения	=	ВыборкаУзловЗначений.ПолучитьУзел(Сч);
			Если УсловияВыполняются(УзелЗначения.ВыбратьУзел("Условия"), Операция) = 1 Тогда
				УзелНайден = 1;
				Прервать;
			КонецЕсли;
		КонецЦикла;
	КонецЕсли;
	Если УзелНайден = 0 Тогда
		ЗаписатьОшибку("У правила - " + ИдПравила + " - не найдено соответствие для значения: " + Счет, "!");
		Возврат(0);
	КонецЕсли;
	
	//Если ПустоеЗначение(УзелЗначения) = 1 Тогда
	//	ЗаписатьОшибку("У правила - " + ИдПравила + " - не найдено соответствие для значения: " + Счет, "!");
	//	Возврат;
	//КонецЕсли;
	
	УстановитьАтрибут(УзелПроводки, "Счет" + ДтИлиКт,	УзелЗначения.ПолучитьАтрибут("Приемник"));
	
	
	Если ПустоеЗначение(УзелЗначения.ПолучитьАтрибут("ЕстьПроцедура")) = 0 Тогда
		ИдПравилаЗначения	=	УзелЗначения.ПолучитьАтрибут("Ид");
		Зн					=	ДополнительныеПреобразования("ПравилоЗначения", ИдПравилаЗначения, Операция, УзелПроводки);
		Если Зн = "#УдалитьТекущуюПроводку" Тогда
			Возврат(0);
			//УзелОперации.УдалитьПодчиненный(УзелПроводки);
		КонецЕсли;
		Возврат(1);
	КонецЕсли;
	
	
	ПравилаСубконто	=	УзелЗначения.ВыбратьУзлы("Реквизит");
	Для СчПравил = 0 По ПравилаСубконто.КоличествоУзлов() - 1 Цикл
		ПравилоСубконто	=	ПравилаСубконто.ПолучитьУзел(СчПравил);
		Результат		=	ДобавитьЗначениеСубконто(ПравилоСубконто, Операция, УзелПроводки, УзелОперации, ДтИлиКт, "#Получить");
		Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
	КонецЦикла;
	               
	Возврат(1);
	
КонецФункции		//	ВыгрузитьКорреспонденцию()

//--------------------------------------------------------------------------------------------------

Процедура ВыгрузитьОперациюДокумента(ДокОперации, Приемник, ИдПравила="")
	                                 
	Перем	ТабРеквизитов;
	Перем	ТабРеквизитовСтрок;
	Перем	Правило;
	
	Операция	=	ДокОперации.Операция;
	
	Если НайтиПравило(Операция, Правило, ИдПравила) = 0	Тогда	Возврат	КонецЕсли;

	гТабКэшПравил.ТабРеквизитов.Выгрузить(ТабРеквизитов);
	гТабКэшПравил.ТабРеквизитовСтрок.Выгрузить(ТабРеквизитовСтрок);
	
	УзелОперации	=	Приемник.СоздатьПодчиненныйЭлемент("Операция");
	УстановитьАтрибут(УзелОперации,	"Правило", 	ИдПравила);
	
	ЗагрузитьПараметрыЗагрузки("", гТабКэшПравил.ПараметрыЗагрузки);
	СпособЗагрузкиПоУмолчанию	=	гТабКэшПараметровЗагрузки.СпособЗагрузки;
	
	ТабРеквизитов.ВыбратьСтроки();
	Пока ТабРеквизитов.ПолучитьСтроку() = 1 Цикл
		Результат = ДобавитьРеквизит(ТабРеквизитов, Операция, УзелОперации, "#Получить", СпособЗагрузкиПоУмолчанию);
		Если Результат = "#Прервать" Тогда Прервать КонецЕсли;
	КонецЦикла;
	
	
	Операция.ВыбратьПроводки();
	Пока Операция.ПолучитьПроводку() = 1 Цикл
		
		УзелПроводки	=	УзелОперации.СоздатьПодчиненныйЭлемент("Проводка");
		УстановитьАтрибут(УзелПроводки,	"Сложная", 	Операция.СложнаяПроводка() );
		
		Если Операция.ПланСчетов() <> ОсновнойПланСчетов() Тогда
			УстановитьАтрибут(УзелПроводки,	"ПланСчетов", 	Операция.ПланСчетов().Идентификатор());
		КонецЕсли;
		
		ТабРеквизитовСтрок.ВыбратьСтроки();
		Пока ТабРеквизитовСтрок.ПолучитьСтроку() = 1 Цикл
			
			ИдПравилаРеквизитов		=	ТабРеквизитовСтрок.Ид;
			ВидУсловия				=	ТабРеквизитовСтрок.ВидУсловия;
			ЕстьПроцедура			=	ТабРеквизитовСтрок.ЕстьПроцедура;
			
			Если		ВидУсловия = 1 Тогда	//	условие задано по операции
				Условия					=	ТабРеквизитовСтрок.Условия;
				Если УсловияВыполняются(Условия, Операция) = 0 Тогда Продолжить КонецЕсли;
			ИначеЕсли	ВидУсловия = 2 Тогда	//	условие задано по реквизиту (атрибуту) проводки
				Условия					=	ТабРеквизитовСтрок.Условия;
			КонецЕсли;
			
			Источник_Ид				=	ТабРеквизитовСтрок.Источник_Ид;
			Источник_ТипАтрибута	=	ТабРеквизитовСтрок.Источник_ТипАтрибута;
			
			Приемник_Ид				=	ТабРеквизитовСтрок.Приемник_Ид;
			Приемник_ТипАтрибута	=	ТабРеквизитовСтрок.Приемник_ТипАтрибута;
			Приемник_Тип			=	ТабРеквизитовСтрок.Приемник_Тип;
			Приемник_Вид			=	ТабРеквизитовСтрок.Приемник_Вид;
			Приемник_Длина			=	ТабРеквизитовСтрок.Приемник_Длина;
			
			Преобразование			=	ТабРеквизитовСтрок.Преобразование;
			ПравилоВыгрузки			=	ТабРеквизитовСтрок.Правило;
			
			ПараметрыПравила		=	ТабРеквизитовСтрок.ПараметрыПравила;
			//ПолучитьИзПараметров	=	ТабРеквизитовСтрок.ПолучитьИзПараметров;
			
			СпособЗагрузки			=	ТабРеквизитовСтрок.СпособЗагрузки;
			
			
			                  
			ПрерватьПослеОбработки	=	0;
			Если		ПустоеЗначение(ЕстьПроцедура) = 0	Тогда
				Зн	=	ДополнительныеПреобразования("ПравилоРеквизита", ИдПравилаРеквизитов, Операция, УзелПроводки);
				Если		Зн = 0 Тогда
					Продолжить;
				ИначеЕсли	Зн = "#Прервать" Тогда
					Прервать;	//	Получить следующую проводку
				ИначеЕсли	Зн = "#ПрерватьПослеОбработки" Тогда
					ЕстьПроцедура			=	0;
					ПрерватьПослеОбработки	=	1;
				ИначеЕсли	Зн = "#УдалитьТекущуюПроводку" Тогда
					УзелОперации.УдалитьПодчиненный(УзелПроводки);
					Прервать;	//	Получить следующую проводку
				КонецЕсли;
			КонецЕсли;
			
			
			//	получаем значение реквизита объекта источника
			                                                     
			Если ПустоеЗначение(ЕстьПроцедура) = 1 Тогда
				
				Если		Источник_ТипАтрибута = "М"			Тогда
					Зн	=	ПолучитьЗначениеМетодом(Операция, Источник_Ид);
				ИначеЕсли	Источник_Ид = "СчетДт"				Тогда
					Зн	=	Операция.Дебет.Счет;
				ИначеЕсли	Источник_Ид = "СчетКт"				Тогда
					Зн	=	Операция.Кредит.Счет;
				ИначеЕсли	ПустоеЗначение(Источник_Ид) = 1		Тогда
					Зн	=	"";
				Иначе
					Зн	=	Операция.ПолучитьАтрибут(Источник_Ид);
				КонецЕсли;
				
			КонецЕсли;
			
			
			Если ВидУсловия = 2 Тогда	//	т.е. задано условие по реквизиту (атрибуту) проводки
				Если УсловияВыполняются(Условия, Зн) = 0 Тогда Продолжить КонецЕсли;
			КонецЕсли;
			
			
			//	выполняем преобразования
			
			Если		ПустоеЗначение(Преобразование) = 0	Тогда
				Зн	=	ВыполнитьПреобразование(Преобразование, Операция, Зн, ПравилоВыгрузки, Приемник_Длина);
			КонецЕсли;
            
			                                                         
			Если	ПустоеЗначение(Источник_Ид) = 0		Тогда
				Если	(СпособЗагрузки				=	"ЗамещатьНеПустыми")	Или 
						((СпособЗагрузкиПоУмолчанию	=	"ЗамещатьНеПустыми")	И	(ПустоеЗначение(СпособЗагрузки) = 1))	Тогда
					Если ПустоеЗначение(Зн) = 1 Тогда Продолжить КонецЕсли;
				КонецЕсли;
			КонецЕсли;
		
			
			//	устанавливаем реквизиты приемника
			
			Если		Приемник_ТипАтрибута = "М"	Тогда
				
				Если Приемник_Ид = "ПланСчетов()" Тогда
					УстановитьАтрибут(УзелПроводки,	"ПланСчетов", 	Зн);
				КонецЕсли;
				
			ИначеЕсли	Приемник_Ид = "СчетДт"		Тогда
				
				Если ВыгрузитьКорреспонденцию(Операция,	Зн,	"Дт",	УзелПроводки,	УзелОперации,	ПравилоВыгрузки) = 0 Тогда
					УзелОперации.УдалитьПодчиненный(УзелПроводки);
					Прервать;	//	Получить следующую проводку
				КонецЕсли;
				
			ИначеЕсли	Приемник_Ид = "СчетКт"		Тогда
				
				Если ВыгрузитьКорреспонденцию(Операция,	Зн,	"Кт",	УзелПроводки,	УзелОперации,	ПравилоВыгрузки) = 0 Тогда
					УзелОперации.УдалитьПодчиненный(УзелПроводки);
					Прервать;	//	Получить следующую проводку
				КонецЕсли;
				
			Иначе	//	Реквизиты проводки
				
				УзелСсылки			=	1;		// означает что нам нужна ссылка
				Значение			=	Выгрузить(Зн, ПравилоВыгрузки, УзелСсылки, ПараметрыПравила, Приемник_Тип, Приемник_Вид);
				         
				
				Если (УзелСсылки = 1) И (ПустоеЗначение(Значение) = 1) Тогда Продолжить КонецЕсли;	//	пустые здесь не выгружаем однозначно
				РеквизитПроводки	=	УзелПроводки.СоздатьПодчиненныйЭлемент("Реквизит");
				УстановитьАтрибут(РеквизитПроводки, "Идентификатор",	Приемник_Ид);
				Если		УзелСсылки <> 1 Тогда	// узел ссылки создан
					РеквизитПроводки.ДобавитьПодчиненный(УзелСсылки);
				Иначе
					УстановитьАтрибут(РеквизитПроводки,	"Значение",	Значение);
				КонецЕсли;
				Если	(Приемник_Тип	=	"Неопределенный") Или
						((ПустоеЗначение(Приемник_Вид) = 1) И (Найти("Справочник,Документ,Счет", Приемник_Тип) > 0)) Тогда
					Если ПустоеЗначение(НайтиПравило(Зн, , ПравилоВыгрузки)) = 0 Тогда
						УстановитьАтрибут(РеквизитПроводки,	"ТипЗначения", 	гТабКэшПравил.Приемник_Тип);
						УстановитьАтрибут(РеквизитПроводки,	"ВидЗначения", 	гТабКэшПравил.Приемник_Вид);
					КонецЕсли;
				КонецЕсли;
				
			КонецЕсли;
			              
			Если ПрерватьПослеОбработки = 1 Тогда Прервать КонецЕсли;	//	Получить следующую проводку
			
		КонецЦикла;		//	по реквизитам
		
	КонецЦикла;		//	по проводкам

КонецПроцедуры		//	ВыгрузитьОперациюДокумента()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ЗаписатьПроведениеДокументаПоПравилу(Док, НомСтр)
    
	Перем	ТабРеквизитовПоиска;
	
	гТабКэшПравил.ПолучитьСтрокуПоНомеру( НомСтр );
	
	//Условия					=	гТабКэшПравил.Условия;
	//ВидУсловия				=	гТабКэшПравил.ВидУсловия;
	
	ИдПравила					=	гТабКэшПравил.Ид;
	ПараметрыЗагрузки			=	гТабКэшПравил.ПараметрыЗагрузки;
	//Правило					=	гТабКэшПравил.Правило;
	
	УзелСсылки					=	1;
	
	гТабКэшПравил.ТабРеквизитовПоиска.Выгрузить(ТабРеквизитовПоиска);
	
	
	Если		ОбъектУжеВыгружен(Док, ТабРеквизитовПоиска, ИдПравила, УзелСсылки, "Проведение") = 0 Тогда
		Возврат(0);		//	возможно документ выгружен по другому правилу
	ИначеЕсли	(ПустоеЗначение(УзелСсылки) = 1) Или (УзелСсылки = 1) Тогда
		Возврат(1); 	//	получить следующий документ из выборки
	КонецЕсли;
	
	
	ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
	
	//ЗамещатьНайденные			=	гТабКэшПараметровЗагрузки.ЗамещатьНайденные;
	СтатусПроведения			=	гТабКэшПараметровЗагрузки.СтатусПроведения;
	//ЗагружатьЗаписиЖР			=	гТабКэшПараметровЗагрузки.ЗагружатьЗаписиЖР;
	    
	
	//Если	ЗамещатьНайденные = 0 Тогда Возврат(1) КонецЕсли;	//	откуда нам знать найдется он или нет...
	
	
	Если НужноПровести(Док, СтатусПроведения) = 0 Тогда Возврат(0) КонецЕсли;	//	возможно документ нужно проводить по другому правилу
	
	
	//	Т.к. объект уже выгружен по данному правилу, значит он удовлетворяет условиям
	//
	//Если ВидУсловия = 1 Тогда	//	т.е. условие задано
	//	Если УсловияВыполняются(Условия, Док, ИдПравила) = 0 Тогда Возврат(0) КонецЕсли; //	попробуем по следующему правилу
	//КонецЕсли;
	
		 
	ОбъектМД					=	Метаданные.Документ(Док.Вид());
	XML_DOM						=	гXMLАнализатор.СоздатьДокумент();
	Приемник					=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
	Приемник.ДобавитьПодчиненный(УзелСсылки);
	
    УстановитьАтрибут(Приемник, "Правило", ИдПравила);
	
	
	//----------	Если документ бухгалтерский	----------------------
	
	Если ОбъектМД.БухгалтерскийУчет	=	1 Тогда
		Если	Док.СуществуетОперация() = 1	Тогда
			СтатусПроводок		=	гТабКэшПараметровЗагрузки.СтатусПроводок;
			ЗагружатьОперации	=	гТабКэшПараметровЗагрузки.ЗагружатьОперации;
			ПравилоОпераций		=	гТабКэшПараметровЗагрузки.ПравилоОпераций;
			УстановитьАтрибут(Приемник,	"ВыключитьПроводки",	ВыключитьПроводки(Док, СтатусПроводок));
			Если	(ПустоеЗначение(ЗагружатьОперации) = 0) И (ОбъектМД.СоздаватьОперацию <> "ТолькоПриПроведении") Тогда
				ВыгрузитьОперациюДокумента(Док, Приемник, ПравилоОпераций);
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
	
	//----------	Если документ расчетный	--------------------------
	
	Если ОбъектМД.Расчет = 1 Тогда
		УстановитьПериоды(Док, Приемник, ИдПравила);
	КонецЕсли;
	
	
	ЗаписатьОбъектВФайл(Приемник);
	
	Возврат(0);		//	существуют ситуации, когда один документ превращается в несколько по разным правилам...
		
КонецФункции		//	ЗаписатьПроведениеДокументаПоПравилу()

//--------------------------------------------------------------------------------------------------
                                                                                                    
Процедура ПроведениеДокументов()
	
	ТабВидовДокументов	=	ПодготовитьТаблицуДляПроведения();
	    
	Сч					=	0;
	ДокПроведения		=	СоздатьОбъект("Документ");
	ДокПроведения.ОбратныйПорядок(0);
	//ДокПроведения.ВыбратьДокументы(ФормДатаНач, ФормДатаКон);		// нужно учесть док-ты, выгружаемые по ссылкам
	ДокПроведения.ВыбратьДокументы();
	Пока ДокПроведения.ПолучитьДокумент() = 1 Цикл
		ВидДокумента	=	ДокПроведения.Вид();
		СписокПравил	=	ПолучитьЗначениеКолонки(ТабВидовДокументов, "ВидДокумента", ВидДокумента, "СписокПравил");
		Если ПустоеЗначение(СписокПравил) = 1 Тогда Продолжить КонецЕсли;
		
		//СписокПравил.СортироватьПоПредставлению();
		
		Для СчПравил = 1 По СписокПравил.РазмерСписка() Цикл
			
			Если ЗаписатьПроведениеДокументаПоПравилу(ДокПроведения.ТекущийДокумент(), СписокПравил.ПолучитьЗначение(СчПравил)) = 1 Тогда
				Прервать;	//	получить из выборки следующий документ
			КонецЕсли;
			
		КонецЦикла;
		
	КонецЦикла;

КонецПроцедуры		//	ПроведениеДокументов()
              
//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция ЗаписиЖРДокументаПоПравилу(Док, НомСтр)
    
	Перем	ТабРеквизитовПоиска;
	
	гТабКэшПравил.ПолучитьСтрокуПоНомеру( НомСтр );
	
	//Условия					=	гТабКэшПравил.Условия;
	//ВидУсловия				=	гТабКэшПравил.ВидУсловия;
	
	ИдПравила					=	гТабКэшПравил.Ид;
	ПараметрыЗагрузки			=	гТабКэшПравил.ПараметрыЗагрузки;
	//Правило					=	гТабКэшПравил.Правило;
	УзелСсылки					=	1;
	
	гТабКэшПравил.ТабРеквизитовПоиска.Выгрузить(ТабРеквизитовПоиска);
	    
	
	Если		ОбъектУжеВыгружен(Док, ТабРеквизитовПоиска, ИдПравила, УзелСсылки, "Проведение") = 0 Тогда
		Возврат(0);		//	документ может быть выгружен по другому правилу
	ИначеЕсли	(ПустоеЗначение(УзелСсылки) = 1) Или (УзелСсылки = 1) Тогда
		Возврат(1); 	//	получить следующий документ из выборки
	КонецЕсли;
	
	
	ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
	
	//ЗамещатьНайденные			=	гТабКэшПараметровЗагрузки.ЗамещатьНайденные;
	ЗагружатьЗаписиЖР			=	гТабКэшПараметровЗагрузки.ЗагружатьЗаписиЖР;
	                 
	//Если ПустоеЗначение(ЗамещатьНайденные) = 1 Тогда	Возврат(0)	КонецЕсли;		//	откуда нам знать найдется он или нет...
	
	Если ПустоеЗначение(ЗагружатьЗаписиЖР) = 1 Тогда Возврат(0) КонецЕсли;	//	записи могут выгружаться по другому правилу
	
	
	//	Т.к. объект уже выгружен по данному правилу, значит он удовлетворяет условиям
	//
	//Если ВидУсловия = 1 Тогда	//	т.е. условие задано
	//	Если УсловияВыполняются(Условия, Док, ИдПравила) = 0 Тогда Возврат(0) КонецЕсли;		//	попробуем по следующему правилу
	//КонецЕсли;
	             
	ВыгрузитьЗаписи(Док, ИдПравила, УзелСсылки);
	
	Возврат(0);
		
КонецФункции		//	ЗаписиЖРДокументаПоПравилу()

//--------------------------------------------------------------------------------------------------

Процедура ЗаписиЖРДокументов()
	
	ТабВидовДокументов	=	ПодготовитьТаблицуДляПроведения();
	    
	Сч					=	0;
	ДокПроведения		=	СоздатьОбъект("Документ");
	ДокПроведения.ОбратныйПорядок(0);
	ДокПроведения.УстановитьФильтр(1, 1, 0, 1, 2, 1);
	//ДокПроведения.ВыбратьДокументы(ФормДатаНач, ФормДатаКон);
	ДокПроведения.ВыбратьДокументы();
	Пока ДокПроведения.ПолучитьДокумент() = 1 Цикл
		ВидДокумента	=	ДокПроведения.Вид();
		СписокПравил	=	ПолучитьЗначениеКолонки(ТабВидовДокументов, "ВидДокумента", ВидДокумента, "СписокПравил");
		Если ПустоеЗначение(СписокПравил) = 1 Тогда Продолжить КонецЕсли;
		            
		//СписокПравил.СортироватьПоПредставлению();
		
		Для СчПравил = 1 По СписокПравил.РазмерСписка() Цикл
			
			Если ЗаписиЖРДокументаПоПравилу(ДокПроведения.ТекущийДокумент(), СписокПравил.ПолучитьЗначение(СчПравил)) = 1 Тогда
				Прервать;	//	получить следующий документ из выборки
			КонецЕсли;
			
		КонецЦикла;
		
	КонецЦикла;

КонецПроцедуры		//	ЗаписиЖРДокументов()

//--------------------------------------------------------------------------------------------------

Процедура ЗаписатьОперациюБухИтогов(Док)
		                                             
	ИдПравила	=	"";
	УзелСсылки	=	1;
	Выгрузить(Док, ИдПравила, УзелСсылки, гКолвоОперацийСОстатками);
	
	//	Т.к. объект реально существует только в памяти, то ЗначениеВСтрокуВнутр() возвращает
	//	всегда одно и то же, поэтому указываем параметр "гКолвоОперацийСОстатками", дабы функция
	//	ОбъектУжеВыгружен() правильно отрабатывала...
	
	XML_DOM						=	гXMLАнализатор.СоздатьДокумент();
	Приемник					=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
	Приемник.ДобавитьПодчиненный(УзелСсылки);
	
    УстановитьАтрибут(Приемник,	"Правило", ИдПравила);
	
	ВыгрузитьОперациюДокумента(Док, Приемник);
	
	ЗаписатьОбъектВФайл(Приемник);
	
КонецПроцедуры		//	ЗаписатьОперациюБухИтогов()

//--------------------------------------------------------------------------------------------------

Процедура АрхивированиеДокументов()
	
	Перем	ТабРеквизитовПоиска;
	    
	СписокЖР	=	СоздатьОбъект("СписокЗначений");
	Для Сч = 1 по Метаданные.ЖурналРасчетов() Цикл
		ИдЖР	=	Метаданные.ЖурналРасчетов(Сч).Идентификатор;
		СписокЖР.ДобавитьЗначение( СоздатьОбъект("ЖурналРасчетов." + ИдЖР), ИдЖР);
	КонецЦикла;
	
	ТабВидовДокументов	=	ПодготовитьТаблицуДляПроведения();
	
	XML_DOM				=	гXMLАнализатор.СоздатьДокумент();
	Приемник			=	XML_DOM.СоздатьУзел(1, "АрхивироватьДокументы");
	
	Док					=	СоздатьОбъект("Документ");
	
	Док.ОбратныйПорядок(0);
	Док.УстановитьФильтр(1, 1, 0, 1, 2, 1);
	//Док.ВыбратьДокументы(ФормДатаНач, ФормДатаКон);
	Док.ВыбратьДокументы();
	Пока Док.ПолучитьДокумент() = 1 Цикл
		ВидДокумента	=	Док.Вид();
		СписокПравил	=	ПолучитьЗначениеКолонки(ТабВидовДокументов, "ВидДокумента", ВидДокумента, "СписокПравил");
		Если ПустоеЗначение(СписокПравил) = 1 Тогда Продолжить КонецЕсли;
		            
		//СписокПравил.СортироватьПоПредставлению();
		
		Для СчПравил = 1 По СписокПравил.РазмерСписка() Цикл
			
			гТабКэшПравил.ПолучитьСтрокуПоНомеру( СписокПравил.ПолучитьЗначение(СчПравил) );
			
			УзелСсылки					=	1;
			
			//Условия					=	гТабКэшПравил.Условия;
			//ВидУсловия				=	гТабКэшПравил.ВидУсловия;
			
			ИдПравила					=	гТабКэшПравил.Ид;
			ПараметрыЗагрузки			=	гТабКэшПравил.ПараметрыЗагрузки;
			//Правило					=	гТабКэшПравил.Правило;
			Приемник_Вид				=	гТабКэшПравил.Приемник_Вид;
			
			
			гТабКэшПравил.ТабРеквизитовПоиска.Выгрузить(ТабРеквизитовПоиска);

			
			Если		ОбъектУжеВыгружен(Док.ТекущийДокумент(), ТабРеквизитовПоиска, ИдПравила, УзелСсылки, "Проведение") = 0	Тогда
				Продолжить;		//	возможно документ архивный по другому правилу
			ИначеЕсли	(ПустоеЗначение(УзелСсылки) = 1) Или (УзелСсылки = 1) Тогда
				Прервать;		//	получить следующий документ из выборки
			КонецЕсли;		
			  
			
			//	Т.к. объект уже выгружен по данному правилу, значит он удовлетворяет условиям
			//
			//Если ВидУсловия = 1 Тогда	//	т.е. условие задано
			//	Если УсловияВыполняются(Условия, Док, ИдПравила) = 0 Тогда Продолжить КонецЕсли;	//	попробуем по следующему правилу
			//КонецЕсли;
			
			
			ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
			СтатусРасчетныхДокументов	=	гТабКэшПараметровЗагрузки.СтатусРасчетныхДокументов;
			                         
			Если СтатусРасчетныхДокументов = "НеАрхивировать" Тогда Продолжить КонецЕсли;	//	возможно нужно архивировать по другому правилу
				                              
			УзелСсылки.УстановитьАтрибут("Вид", Приемник_Вид);
			
			
			Если СтатусРасчетныхДокументов = "Архивировать" Тогда
				Приемник.ДобавитьПодчиненный(УзелСсылки);
				Продолжить;
			КонецЕсли;
			             
			
			//	Если СтатусРасчетныхДокументов = "Авто"
			            
			Для СчЖР = 1 по СписокЖР.РазмерСписка() Цикл
				ЖР = СписокЖР.ПолучитьЗначение(СчЖР);
				
				ЖР.ВыбратьЗаписиПоДокументу(Док.ТекущийДокумент());
				Если ЖР.ПолучитьЗапись()=1 Тогда
					НайтиПравило(ЖР, , , , , ИдПравила);
					Периодичность	=	гТабКэшПравил.Уникальность;
					ДатаОтсчета		=	гТабКэшПравил.ДатаОтсчета;
					
					Если		Периодичность = "День" тогда
						ДатаНачалаПериодаПриемника = ЖР.КонецТекущегоПериода();
					ИначеЕсли Периодичность = "Неделя" тогда
						ДатаНачалаПериодаПриемника = НачНедели(ЖР.КонецТекущегоПериода());
						Смещение = ДатаОтсчета - НачНедели(ДатаОтсчета);
						ДатаНачалаПериодаПриемника = ДатаНачалаПериодаПриемника + Смещение;
					ИначеЕсли Периодичность = "Месяц" тогда
						ДатаНачалаПериодаПриемника = НачМесяца(ЖР.КонецТекущегоПериода());
						Смещение = ДатаОтсчета - НачМесяца(ДатаОтсчета);
						ДатаНачалаПериодаПриемника = ДатаНачалаПериодаПриемника + Смещение;
					ИначеЕсли Периодичность = "Квартал" тогда
						ДатаНачалаПериодаПриемника = НачКвартала(ЖР.КонецТекущегоПериода());
						Смещение = ДатаОтсчета - НачКвартала(ДатаОтсчета);
						ДатаНачалаПериодаПриемника = ДатаНачалаПериодаПриемника + Смещение;
					ИначеЕсли Периодичность = "Год" тогда
						ДатаНачалаПериодаПриемника = НачГода(ЖР.КонецТекущегоПериода());
						Смещение = ДатаОтсчета - НачГода(ДатаОтсчета);
						ДатаНачалаПериодаПриемника = ДатаНачалаПериодаПриемника + Смещение;
					КонецЕсли;
					//Если ЖР.ПериодРегистрации.ДатаНачала < ЖР.ТекущийПериод().ДатаНачала Тогда
					Если ЖР.ПериодРегистрации.ДатаНачала < ДатаНачалаПериодаПриемника Тогда
						Приемник.ДобавитьПодчиненный(УзелСсылки);
						Прервать;	//	прервать перебор записей ЖР
					КонецЕсли;
				КонецЕсли;
			КонецЦикла;
			
		КонецЦикла;		//	по списку правил
		
	КонецЦикла;			//	по документам
	
	
	Если ПустоеЗначение(Приемник.ВыбратьУзел("Ссылка")) = 0 Тогда	//	если хоть одна есть...
		ЗаписатьОбъектВФайл(Приемник);
	КонецЕсли;

КонецПроцедуры		//	АрхивированиеДокументов()

//--------------------------------------------------------------------------------------------------

Процедура УстановитьПараметрыПоУмолчанию()

	гТабКэшПараметровЗагрузки.НоваяСтрока();
	гТабКэшПараметровЗагрузки.Ид						=	"ПараметрыПоУмолчанию";
	гТабКэшПараметровЗагрузки.Дата						=	РабочаяДата();
	гТабКэшПараметровЗагрузки.ЗамещатьНайденные			=	1;
	гТабКэшПараметровЗагрузки.СпособЗагрузки			=	"ЗамещатьНеПустыми";
	гТабКэшПараметровЗагрузки.НовыеНеСоздавать			=	0;
	гТабКэшПараметровЗагрузки.СтатусУдаления			=	"Авто";
	гТабКэшПараметровЗагрузки.СтатусПроводок			=	"Авто";
	гТабКэшПараметровЗагрузки.СтатусПроведения			=	"Авто";
	гТабКэшПараметровЗагрузки.СтатусРасчетныхДокументов	=	"Авто";
	гТабКэшПараметровЗагрузки.ЗагружатьОперации			=	1;
	гТабКэшПараметровЗагрузки.ПравилоОпераций			=	"";
	гТабКэшПараметровЗагрузки.ЗагружатьЗаписиЖР			=	1;
	
КонецПроцедуры		//	УстановитьПараметрыПоУмолчанию()




//**************************************************************************************************
//----	Начало вспомогательных функций для написания скриптов	------------------------------------
//**************************************************************************************************

Функция ПравилоПоИмени(Имя)

	Возврат гПравила.ВыбратьУзел("//Правило[@Имя = """ + Имя + """]");
	
КонецФункции

//--------------------------------------------------------------------------------------------------
//	Приемник			-	xml-узел приемник, доступный в скриптах ("ОбъектСправочника", "Докумет",
//							"Строка" документа и т.д. - в зависимости от контекста скрипта)
//	ИдРеквизита			-	идентификатор реквизита приемника
//	Значение			-	значение реквизита источника, если он неагрегатного типа
//	Объект 				-	значение реквизита источника, если он агрегатного типа
//	ТипПриемника		-	тип реквизита приемника (для реквизитов неопределенного типа)
//	ВидПриемника		-	вид реквизита приемника (для реквизитов неопределенного типа)
//	ПравилоИлиИмя		-	ссылка на xml-правило или строка - наименование
//							правила, так, как оно указано в КД (для использования этой
//							возможности, наименования нужных правил следует задавать уникальными)
//	ПараметрыПравила	-	список дополнительных параметров правила

Процедура ВыгрузитьРеквизит(Приемник, ИдРеквизита, Значение="", Объект="", ТипПриемника="", ВидПриемника="", ПравилоИлиИмя="", ПараметрыПравила="")
    
	Если		ПустоеЗначение(Значение) = 0 Тогда
		
		Реквизит	=	Приемник.СоздатьПодчиненныйЭлемент("Реквизит");
		Реквизит.УстановитьАтрибут("Идентификатор",	ИдРеквизита);
		Реквизит.УстановитьАтрибут("Значение",		СокрЛП(Значение));
		УстановитьАтрибут(Реквизит, "ТипЗначения", ТипПриемника);
		УстановитьАтрибут(Реквизит, "ВидЗначения", ВидПриемника);
	
	ИначеЕсли	(ПустоеЗначение(Объект) = 0) Или (ПустоеЗначение(ПравилоИлиИмя) = 0) Тогда
		                           
		УзелСсылки			=	1;
		Правило				=	"";
		ИдПравила			=	"";
		Если ПустоеЗначение(ПравилоИлиИмя) = 0 Тогда
			Правило			=	ПравилоИлиИмя;
			Если ТипЗначенияСтр(ПравилоИлиИмя) = "Строка" Тогда
				Правило		=	ПравилоПоИмени(ПравилоИлиИмя);
			КонецЕсли;
		КонецЕсли;
		ВыгрузитьПоПравилу(Объект, Правило, ИдПравила, УзелСсылки, ПараметрыПравила, ТипПриемника, ВидПриемника);
		Если УзелСсылки <> 1 Тогда
			Реквизит	=	Приемник.СоздатьПодчиненныйЭлемент("Реквизит");
			Реквизит.УстановитьАтрибут("Идентификатор",	ИдРеквизита);
			УстановитьАтрибут(Реквизит, "ТипЗначения", ТипПриемника);
			УстановитьАтрибут(Реквизит, "ВидЗначения", ВидПриемника);
			Реквизит.ДобавитьПодчиненный(УзелСсылки);
		КонецЕсли;
		
	КонецЕсли;
	
КонецПроцедуры		//	ВыгрузитьРеквизит()

//**************************************************************************************************
//----	Конец вспомогательных функций для написания скриптов	------------------------------------
//**************************************************************************************************


                          
Процедура ИнициализироватьСистемныеОбластиТаблицы()

	ТабОбласть2	=	гКонт.Таблица.Область(1, 1, 1, 2);
	ТабОбласть2.Объединить();
	ТабОбласть2.ГоризонтальноеПоложение(3);
	ТабОбласть2.Контроль(1);
	ТабОбласть2.ВысотаСтроки(18);
	ТабОбласть2.РамкаОбвести(2, 2, 2, 2);
	ТабОбласть2.Текст	=	"Начало выгрузки  -  " + ТекущееВремя();
	
	ТабОбласть3	=	гКонт.Таблица.Область(1, 3, 1, 4);
	ТабОбласть3.Объединить();
	ТабОбласть3.ГоризонтальноеПоложение(3);
	ТабОбласть3.Контроль(1);
	ТабОбласть3.ВысотаСтроки(18);
	ТабОбласть3.РамкаОбвести(2, 2, 2, 2);
	ТабОбласть3.Текст	=	"Конец выгрузки -  ";

	ТабОбласть1	=	гКонт.Таблица.Область(2, 1, 2, 4);
	ТабОбласть1.Объединить();
	ТабОбласть1.ГоризонтальноеПоложение(3);
	ТабОбласть1.Контроль(1);
	ТабОбласть1.ВысотаСтроки(22);
	ТабОбласть1.Текст	=	"Обрабатывается правило:";
	
	ТабОбласть4	=	гКонт.Таблица.Область(3, 1, 3, 4);
	ТабОбласть4.Объединить();
	ТабОбласть4.ГоризонтальноеПоложение(3);
	ТабОбласть4.Контроль(1);
	ТабОбласть4.ВысотаСтроки(22);
	ТабОбласть4.Текст	=	"";

	//гКонт.Таблица.Показать();
	
КонецПроцедуры

//--------------------------------------------------------------------------------------------------

Процедура ВыгрузитьДанные()
	                                 
	Если Метаданные.ПланСчетов(1).Выбран() = 1 Тогда
		гБухИтоги = СоздатьОбъект("БухгалтерскиеИтоги");
	КонецЕсли;
	
	ИнициализироватьСистемныеОбластиТаблицы();

	гСчетчикВыгруженныхОбъектов				=	0;
	//СписокСписковВыгруженныхОбъектов		=	СоздатьОбъект("СписокЗначений"); 
	
	СписокУзловДобавляемыхПослеПроведения	=	СоздатьОбъект("СписокЗначений");
	
	ТабВыгруженныхОбъектов					=	СоздатьОбъект("ТаблицаЗначений");
	ТабВыгруженныхОбъектов.НоваяКолонка("ИдПравила",	"Строка");
	ТабВыгруженныхОбъектов.НоваяКолонка("ТабОбъектов",	"ТаблицаЗначений");
	
	//гСписокОбработанныхПравил				=	СоздатьОбъект("СписокЗначений");
	//гСписокНеобработанныхПравил			=	СоздатьОбъект("СписокЗначений");
	
	гТабКэшРеквизитовЗначений.УдалитьСтроки();
	гТабКэшПравил.УдалитьСтроки();
	гТабКэшПараметровЗагрузки.УдалитьСтроки();
	УстановитьПараметрыПоУмолчанию();
	

	ПравилаОбмена							=	гПравила.ВыбратьУзел("ПравилаОбмена");
	                                                                                  
	
	гФайлДанных								=	гXMLАнализатор.СоздатьПоследовательноЗаписываемыйДокумент();
	гФайлДанных.ИмяФайла					=	ФормИмяФайлаДанных;
	
	АтрибутыЭлемента						=	гФайлДанных.АтрибутыЭлемента;
	АтрибутыЭлемента.УстановитьАтрибут("ВерсияФормата",				"1.0");
	АтрибутыЭлемента.УстановитьАтрибут("ИдКонфигурацииПриемника",	ПравилаОбмена.ПолучитьАтрибут("ИдКонфигурацииПриемника"),	0);
	АтрибутыЭлемента.УстановитьАтрибут("ИдПравилКонвертации",		ПравилаОбмена.ПолучитьАтрибут("Ид"), 						0);
	АтрибутыЭлемента.УстановитьАтрибут("ДатаНачала",				ПолучитьИдОбъектаИсточника(ФормДатаНач)  );
	АтрибутыЭлемента.УстановитьАтрибут("ДатаОкончания",				ПолучитьИдОбъектаИсточника(ФормДатаКон)  );
	//АтрибутыЭлемента.УстановитьАтрибут("Комментарий",				,	0);
	
	гФайлДанных.ОткрытьЭлемент("ФайлОбмена");
	 
	
	//Если ФормФлВключатьПравилаВФайл = 1 Тогда
		гФайлДанных.ВключитьЭлемент(ПравилаОбмена);
		гФайлДанных.Сбросить();
	//КонецЕсли;
	 
	
	//-----		Загружаем правила с выборками	---------------------------
	
	//Если ФормФлВыгружатьТолькоИнтерактивные	= 0	Тогда
	//	ВыборкаПравил = гПравила.ВыбратьУзлы("//Правило[@ПоСсылкам=0]");
	//	Для Сч = 0 По ВыборкаПравил.КоличествоУзлов() - 1 Цикл
	//		Эл_Правило	=	ВыборкаПравил.ПолучитьУзел(Сч);
	//		ЗагрузитьПравило(Эл_Правило);
	//	КонецЦикла;
	//	гТабКэшПравил.Выгрузить(гСписокНеобработанныхПравил, , , "Ид");
	//КонецЕсли;
                                     
	//-----		Последовательно обрабатываем правила конвертации	-------
	
	ВыборкаПравил = гПравила.ВыбратьУзлы("//Правило");
	Для Сч = 0 По ВыборкаПравил.КоличествоУзлов() - 1 Цикл
		Эл_Правило	=	ВыборкаПравил.ПолучитьУзел(Сч);
		Если ВыгрузитьДанныеПоПравилу(Эл_Правило) = "Возврат" Тогда Возврат КонецЕсли;
	КонецЦикла;
	
	
	//-----		Обработка архивных расчетных документов		---------------
	          
	Если (Метаданные.ЖурналРасчетов() > 0) И (ПустоеЗначение(ФормФлНеОбрабатыватьПроведение) = 1) Тогда
		Если гБезОткрытияФормы = 1 Тогда
			//Сообщить("Выполняется обработка архивных расчетных документов");
		Иначе
			ТабОбласть4.Текст	=	"Обработка архивных расчетных документов";
			гКонт.Таблица.Показать();
		КонецЕсли;
		АрхивированиеДокументов();
	КонецЕсли;
	                                                                       
	
	//-----		Проведение документов	-----------------------------------
	                    
	Если ПустоеЗначение(ФормФлНеОбрабатыватьПроведение) = 1 Тогда
		Если гБезОткрытияФормы = 1 Тогда
			//Сообщить("Выполняется обработка проведенных документов");
		Иначе
			ТабОбласть4.Текст		=	"Обработка проведенных документов";
			гКонт.Таблица.Показать();
		КонецЕсли;
		ПроведениеДокументов();
	КонецЕсли;

	
	//-----		Выгрузка xml-объектов, добавленных в предопределенный список в скриптах	---------------
	
	Для Сч = 1 По СписокУзловДобавляемыхПослеПроведения.РазмерСписка() Цикл
		ЗаписатьОбъектВФайл(СписокУзловДобавляемыхПослеПроведения.ПолучитьЗначение(Сч));
	КонецЦикла;
	
	
	//-----		Выгрузка запсией ЖР расчетных документов		---------------
	
	Если (Метаданные.ЖурналРасчетов() > 0) И (ПустоеЗначение(ФормФлНеОбрабатыватьПроведение) = 1) Тогда
		Если гБезОткрытияФормы = 1 Тогда
			//Сообщить("Выполняется выгрузка записей журналов расчетов");
		Иначе
			ТабОбласть4.Текст	=	"Выгрузка записей журналов расчетов";
			гКонт.Таблица.Показать();
		КонецЕсли;
		ЗаписиЖРДокументов();
	КонецЕсли;
	
	
	//-----		Формирование и выгрузка бух. итогов	-----------------------
	
	Если (ФормФлНеВыгружатьБухИтоги = 0) И (Метаданные.ПланСчетов(1).Выбран() = 1) Тогда
		Если гБезОткрытияФормы = 1 Тогда
			Сообщить("Выполняется выгрузка бухгалтерских итогов");
		Иначе
			ТабОбласть4.Текст			=	"Выгрузка бухгалтерских итогов";
			гКонт.Таблица.Показать();
		КонецЕсли;
		гКолвоОперацийСОстатками	=	1;
		ЗакрытиеСчетов();
	КонецЕсли;
	
	
	//-----		Установка текущих периодов журналов расчетов	-----------
	
	Для СчЖурналов = 1 По Метаданные.ЖурналРасчетов() Цикл
		ВидЖР	=	Метаданные.ЖурналРасчетов(СчЖурналов).Идентификатор;
		ЖР		=	СоздатьОбъект( "ЖурналРасчетов." + ВидЖР);
		
		Если НайтиПравило(ЖР) = 0 Тогда Продолжить КонецЕсли;
		                               
		ПараметрыЗагрузки			=	гТабКэшПравил.ПараметрыЗагрузки;
		ВидЖРПриемника				=	гТабКэшПравил.Приемник_Вид;
		
		ЗагрузитьПараметрыЗагрузки("", ПараметрыЗагрузки);
		ДатаТекущегоПериодаЖР		=	гТабКэшПараметровЗагрузки.ДатаТекущегоПериодаЖР;
		Если ПустоеЗначение(ДатаТекущегоПериодаЖР) = 1 Тогда
			ДатаТекущегоПериодаЖР	=	ЖР.ТекущийПериод().ДатаНачала;
		КонецЕсли;
		
		//	установим текущий период

		XML_DOM						=	гXMLАнализатор.СоздатьДокумент();
		ТекущийПериодЖР				=	XML_DOM.СоздатьУзел(1, "УстановитьТекущийПериодЖР");
		УстановитьАтрибут(ТекущийПериодЖР,	"ВидЖР", 	ВидЖРПриемника);
		УстановитьАтрибут(ТекущийПериодЖР,	"Дата", 	Формат(ДатаТекущегоПериодаЖР, "ДДДММГГГГ") );
		ЗаписатьОбъектВФайл(ТекущийПериодЖР);
	КонецЦикла;
	
	
	//---------------------------------------------------------------------
	
	
	гФайлДанных.ЗакрытьЭлемент();
	гФайлДанных.Сбросить();
	гФайлДанных.Завершить();
           
	
	//гФлагВыгрузкаПроизведена	=	1;
	
	Состояние("Выгрузка данных завершена!");


	Если гБезОткрытияФормы = 1 Тогда
		Сообщить("Выгрузка данных завершена!");
		Сообщить("Выгружено объектов:   " + гСчетчикВыгруженныхОбъектов);
	Иначе
		ТабОбласть3.Текст	=	"Конец выгрузки -  " + ТекущееВремя();
		ТабОбласть1.Текст	=	"Выгрузка данных завершена!";
		ТабОбласть4.Текст	=	"Выгружено объектов:   " + гСчетчикВыгруженныхОбъектов;
		гКонт.Таблица.Показать();
	КонецЕсли;
	
	
КонецПроцедуры		//	ВыгрузитьДанные()
            
//--------------------------------------------------------------------------------------------------

Процедура ПриОткрытии()
        
	СтатусВозврата(0);
	
	//Если Фс.СуществуетФайл(гПутьОбъекта_ИсполняемыйКод) = 1 Тогда Фс.УдалитьФайл(гПутьОбъекта_ИсполняемыйКод) КонецЕсли;
	
	гXMLАнализатор		=	СоздатьОбъект("AddIn.XMLParser");
	
	СписокПараметров	=	Форма.Параметр;
	Если ПустоеЗначение(СписокПараметров) = 1 Тогда
		Предупреждение("Данная обработка не может использоваться самостоятельно!");
		Возврат;
	КонецЕсли;
	
	гКонт								=	СписокПараметров.Получить("Контекст");
	                                                    
	гПравила							=	СписокПараметров.Получить("гПравила");
	гТабОбъектов						=	СписокПараметров.Получить("гТабОбъектов");
	
	гБезОткрытияФормы					=	СписокПараметров.Получить("БезОткрытияФормы");
	
	гСписокПараметров					=	СписокПараметров.Получить("СписокПараметров");
    
	                 
	Если ТипЗначенияСтр(гСписокПараметров) <> "СписокЗначений" Тогда
		гСписокПараметров	=	СоздатьОбъект("СписокЗначений");
	КонецЕсли;

	    
	НачальнаяИнициализация();
	
	ВыгрузитьДанные();
	
КонецПроцедуры		//	ПриОткрытии()

//--------------------------------------------------------------------------------------------------

Процедура НачальнаяИнициализация()
	
	
	ФормДатаНач							=	гКонт.ФормДатаНач;
	ФормДатаКон							=	гКонт.ФормДатаКон;
	ФормИмяФайлаДанных					=	гКонт.ФормИмяФайлаДанных;
                                                                        
	ФормФлНеВыгружатьБухИтоги			=	гКонт.ФормФлНеВыгружатьБухИтоги;
	ФормДатаРасчетаБухИтогов			=	гКонт.ФормДатаРасчетаБухИтогов;
	ФормКодСчетаДляВводаОстатков		=	гКонт.ФормКодСчетаДляВводаОстатков;
	ФормМаксКолвоПроводок				=	гКонт.ФормМаксКолвоПроводок;
	ФормПланыСчетов						=	гКонт.ФормПланыСчетов;
	ФормРазделителиУчета				=	гКонт.ФормРазделителиУчета;
	
	ФормКолвоБуферизуемыхОбъектов		=	гКонт.ФормКолвоБуферизуемыхОбъектов;
	ФормФлВключатьПравилаВФайл			=	гКонт.ФормФлВключатьПравилаВФайл;
	ФормФлНеОбрабатыватьПроведение		=	гКонт.ФормФлНеОбрабатыватьПроведение;
	ФормФлВыгружатьТолькоИнтерактивные	=	гКонт.ФормФлВыгружатьТолькоИнтерактивные;
	
	ФормФлЗапоминатьСсылки				=	гКонт.ФормФлЗапоминатьСсылки;
	
	
	////////////////////////////////////////////////////////////////////////////////////////////////////
	//	

	РасположениеФайла(гСтрПуть, гИмяФайла);
	
	гПутьОбъекта_ИсполняемыйКод			=	КаталогИБ() + "CDExpVar.txt";
	
	
	////////////////////////////////////////////////////////////////////////////////////////////////////
	//	Инициализация кэш-таблиц
	
	гТабКэшРеквизитов	=	СоздатьОбъект("ТаблицаЗначений");
	гТабКэшРеквизитов.НоваяКолонка("Ид",								"Строка");
	
	гТабКэшРеквизитов.НоваяКолонка("Источник_Ид",						"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Источник_ТипАтрибута",				"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Источник_Тип",						"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Источник_Вид",						"Строка");
	
	гТабКэшРеквизитов.НоваяКолонка("Приемник_Ид",						"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Приемник_ТипАтрибута",				"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Приемник_Тип",						"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Приемник_Вид",						"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Приемник_Длина",					"Число");
	
	гТабКэшРеквизитов.НоваяКолонка("Преобразование",					"Строка");
	гТабКэшРеквизитов.НоваяКолонка("Правило",							"Строка");
	
	//гТабКэшРеквизитов.НоваяКолонка("ЕстьПроцедура",					"Число", 1, 0);
	//гТабКэшРеквизитов.НоваяКолонка("ПолучитьИзПараметров",			"Число", 1, 0);
	
	гТабКэшРеквизитов.НоваяКолонка("ЕстьПроцедура",						"Число");	//	так работает быстрее
	гТабКэшРеквизитов.НоваяКолонка("ПолучитьИзПараметров",				"Число");
	
	гТабКэшРеквизитов.НоваяКолонка("ПараметрыПравила",					"Строка");
	
	гТабКэшРеквизитов.НоваяКолонка("СпособВыгрузки",					"Строка");
	гТабКэшРеквизитов.НоваяКолонка("СпособЗагрузки",					"Строка");
	
	гТабКэшРеквизитов.НоваяКолонка("Условия");
	гТабКэшРеквизитов.НоваяКолонка("ВидУсловия", 						"Число");	// 0 - не задано, 1 - по объекту, 2 - по реквизиту
	
	//--------------------
	
	гТабКэшРеквизитовЗначений	=	СоздатьОбъект("ТаблицаЗначений");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Ид",						"Строка");
	
	гТабКэшРеквизитовЗначений.НоваяКолонка("Источник_Ид",				"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Источник_Тип",				"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Источник_Вид",				"Строка");
	
	гТабКэшРеквизитовЗначений.НоваяКолонка("Приемник_Ид",				"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Приемник_Тип",				"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Приемник_Вид",				"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Приемник_Длина",			"Число");
	
	гТабКэшРеквизитовЗначений.НоваяКолонка("Преобразование",			"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("Правило",					"Строка");
	гТабКэшРеквизитовЗначений.НоваяКолонка("ЕстьПроцедура",				"Число");
	
	гТабКэшРеквизитовЗначений.НоваяКолонка("ПараметрыПравила",			"Строка");
	
	гТабКэшРеквизитовЗначений.НоваяКолонка("Условия");
	гТабКэшРеквизитовЗначений.НоваяКолонка("ВидУсловия", 				"Число");	// 1 - условие задано
	
	//--------------------
	
	гТабКэшПравил	=	СоздатьОбъект("ТаблицаЗначений");
	гТабКэшПравил.НоваяКолонка("Ид",									"Строка");
	
	гТабКэшПравил.НоваяКолонка("Правило");
	гТабКэшПравил.НоваяКолонка("Условия");
	гТабКэшПравил.НоваяКолонка("ВидУсловия", 							"Число");	// 1 - условие задано
	
	гТабКэшПравил.НоваяКолонка("ПоСсылкам",								"Число");
	
	гТабКэшПравил.НоваяКолонка("Источник_Тип",							"Строка");
	гТабКэшПравил.НоваяКолонка("Источник_Вид",							"Строка");
	
	гТабКэшПравил.НоваяКолонка("Приемник_Тип",							"Строка");
	гТабКэшПравил.НоваяКолонка("Приемник_Вид",							"Строка");
	
	гТабКэшПравил.НоваяКолонка("ИдСинхронизирующегоРеквизита",			"Строка");
	
	гТабКэшПравил.НоваяКолонка("Преобразование",						"Строка");
	гТабКэшПравил.НоваяКолонка("ПравилоПереадресации",					"Строка");
	гТабКэшПравил.НоваяКолонка("ПараметрыЗагрузки",						"Строка");
	
	Если Метаданные.ЖурналРасчетов() > 0 Тогда
		гТабКэшПравил.НоваяКолонка("Уникальность",						"Строка");
		гТабКэшПравил.НоваяКолонка("ДатаОтсчета",						"Дата");
	КонецЕсли;
	
	гТабКэшПравил.НоваяКолонка("ТабРеквизитовПоиска",					"ТаблицаЗначений");
	гТабКэшПравил.НоваяКолонка("ТабРеквизитов",							"ТаблицаЗначений");
	гТабКэшПравил.НоваяКолонка("ТабРеквизитовСтрок",					"ТаблицаЗначений");
	
	//--------------------
	
	гТабКэшПараметровЗагрузки	=	СоздатьОбъект("ТаблицаЗначений");
	гТабКэшПараметровЗагрузки.НоваяКолонка("Ид",						"Строка");
	гТабКэшПараметровЗагрузки.НоваяКолонка("Дата",						"Дата");
	
	гТабКэшПараметровЗагрузки.НоваяКолонка("ЗамещатьНайденные",			"Число");
	гТабКэшПараметровЗагрузки.НоваяКолонка("НовыеНеСоздавать",			"Число");
	
	гТабКэшПараметровЗагрузки.НоваяКолонка("СпособЗагрузки",			"Строка");
	гТабКэшПараметровЗагрузки.НоваяКолонка("СтатусУдаления",			"Строка");
	гТабКэшПараметровЗагрузки.НоваяКолонка("СтатусПроводок",			"Строка");
	гТабКэшПараметровЗагрузки.НоваяКолонка("СтатусПроведения",			"Строка");
	гТабКэшПараметровЗагрузки.НоваяКолонка("СтатусРасчетныхДокументов",	"Строка");
	
	гТабКэшПараметровЗагрузки.НоваяКолонка("ДатаТекущегоПериодаЖР",		"Дата");
	
	гТабКэшПараметровЗагрузки.НоваяКолонка("ЗагружатьОперации",			"Число");
	гТабКэшПараметровЗагрузки.НоваяКолонка("ЗагружатьЗаписиЖР",			"Число");
	
	гТабКэшПараметровЗагрузки.НоваяКолонка("ПравилоОпераций");
	
КонецПроцедуры		//	НачальнаяИнициализация()

//--------------------------------------------------------------------------------------------------





//	Есть вручную введенные данные в БЛ
Функция Условие_ID1С_0000523(Объект, ИдПравила)

	Если (Объект.КварталкуВручную = 1) или (Объект.ГодовуюВручную = 1) или (Объект.ЕдиновременнуюВручную = 1) тогда
		Возврат 1;
	КонецЕсли;
	Возврат 0;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ВводОстатковНезавПроизв (Документ)
Функция ПравилоВыборкиОбъектов_ВводОстатковНезавПроизв_F43A000055(ИдПравила)

	Перем	СписокПараметров;
	
	//	Формируем список параметров
	    
	ПредыдущийИндекс	=	"";
	
	ТаблицаКорреспонденцийДокументаОстатков.Сортировать("Субконто1Дебета, Субконто6Дебета");
	ТаблицаКорреспонденцийДокументаОстатков.ВыбратьСтроки();
	Пока ТаблицаКорреспонденцийДокументаОстатков.ПолучитьСтроку() = 1 Цикл
		
		Подразделение	=	ТаблицаКорреспонденцийДокументаОстатков.Субконто1Дебета;
		Владелец		=	ТаблицаКорреспонденцийДокументаОстатков.Субконто6Дебета;
		
		ВидЗатрат		=	ТаблицаКорреспонденцийДокументаОстатков.Субконто2Дебета;
		Затрата			=	ТаблицаКорреспонденцийДокументаОстатков.Субконто3Дебета;
		Продукция		=	ТаблицаКорреспонденцийДокументаОстатков.Субконто4Дебета;
		Заказ			=	ТаблицаКорреспонденцийДокументаОстатков.Субконто5Дебета;
		
		Сумма			=	ТаблицаКорреспонденцийДокументаОстатков.Сумма;
		Количество		=	ТаблицаКорреспонденцийДокументаОстатков.Количество;
		                      
		Индекс			=	ЗначениеВСтрокуВнутр(Подразделение) + ЗначениеВСтрокуВнутр(Владелец);
		
		
		Если Индекс <> ПредыдущийИндекс Тогда
			Если ПредыдущийИндекс <> "" Тогда		//	Выгружаем объект
				УзелСсылки		=	1;
				СчДокументов	=	1 + СчДокументов;
				СписокПараметров.Установить("Комментарий",		"#Выгрузка данных из конфигурации ""Зарплата + Кадры"" (" + СчДокументов + ")");
				ВыгрузитьПоПравилу( , , ИдПравила, УзелСсылки, СписокПараметров);
				
				XML_DOM			=	гXMLАнализатор.СоздатьДокумент();
				УзелПроведения	=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
				УзелПроведения.ДобавитьПодчиненный(УзелСсылки);
			    УстановитьАтрибут(УзелПроведения,	"Правило", ИдПравила);
				ЗаписатьОбъектВФайл(УзелПроведения);
			КонецЕсли;
			ПредыдущийИндекс	=	Индекс;
			СписокПараметров	=	СоздатьОбъект("СписокЗначений");
			СписокПараметров.Установить("Подразделение",	Подразделение);
			СписокПараметров.Установить("Владелец",			Владелец);
		КонецЕсли;                                       
	
		
		ПараметрыСтроки	=	СоздатьОбъект("СписокЗначений");
		
		СписокПараметров.ДобавитьЗначение(ПараметрыСтроки,	"#Строка");
		
		ПараметрыСтроки.Установить("ВидЗатрат",		ВидЗатрат);
		ПараметрыСтроки.Установить("Затрата",		Затрата);
		ПараметрыСтроки.Установить("Продукция",		Продукция);
		ПараметрыСтроки.Установить("Заказ",			Заказ);
		ПараметрыСтроки.Установить("Сумма",			Сумма);
		ПараметрыСтроки.Установить("Количество",	Количество);
		
	КонецЦикла;
	
	
	Если ПредыдущийИндекс <> "" Тогда		//	Выгружаем объект
		УзелСсылки		=	1;
		СчДокументов	=	1 + СчДокументов;
		СписокПараметров.Установить("Комментарий",		"#Выгрузка данных из конфигурации ""Зарплата + Кадры"" (" + СчДокументов + ")");
		ВыгрузитьПоПравилу( , , ИдПравила, УзелСсылки, СписокПараметров);
		
		XML_DOM			=	гXMLАнализатор.СоздатьДокумент();
		УзелПроведения	=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
		УзелПроведения.ДобавитьПодчиненный(УзелСсылки);
	    УстановитьАтрибут(УзелПроведения,	"Правило", ИдПравила);
		ЗаписатьОбъектВФайл(УзелПроведения);
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  НачислениеЗП (Документ)
Функция ПравилоВыборкиОбъектов_НачислениеЗП_F43A000053(ИдПравила)

	Перем	СписокПараметров;
	
	//	Формируем список параметров
	    
	ПредыдущееПодразделение	=	"";
	НачисленоИтого			=	0;
	
	ТаблицаДокументаНачисление.Сортировать("Подразделение");
	ТаблицаДокументаНачисление.ВыбратьСтроки();
	Пока ТаблицаДокументаНачисление.ПолучитьСтроку() = 1 Цикл
		
		Подразделение	=	ТаблицаДокументаНачисление.Подразделение;
		Сотрудник		=	ТаблицаДокументаНачисление.Сотрудник;
		Оклад			=	ТаблицаДокументаНачисление.Сумма;
		
		Если Подразделение <> ПредыдущееПодразделение Тогда
			Если ПредыдущееПодразделение <> "" Тогда		//	Выгружаем объект
				УзелСсылки		=	1;
				СчДокументов	=	1 + СчДокументов;
				СписокПараметров.Установить("Комментарий",		"#Выгрузка данных из конфигурации ""Зарплата + Кадры"" (" + СчДокументов + ")");
				СписокПараметров.Установить("НачисленоИтого",	НачисленоИтого);
				ВыгрузитьПоПравилу( , , ИдПравила, УзелСсылки, СписокПараметров);
				
				XML_DOM			=	гXMLАнализатор.СоздатьДокумент();
				УзелПроведения	=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
				УзелПроведения.ДобавитьПодчиненный(УзелСсылки);
			    УстановитьАтрибут(УзелПроведения,	"Правило", ИдПравила);
				ЗаписатьОбъектВФайл(УзелПроведения);
			КонецЕсли;
			НачисленоИтого			=	0;
			ПредыдущееПодразделение	=	Подразделение;
			СписокПараметров		=	СоздатьОбъект("СписокЗначений");
			СписокПараметров.Установить("Подразделение",	Подразделение);
		КонецЕсли;                                       
	
		НачисленоИтого	=	НачисленоИтого + Оклад;
		ПараметрыСтроки	=	СоздатьОбъект("СписокЗначений");
		
		СписокПараметров.ДобавитьЗначение(ПараметрыСтроки,	"#Строка");
		
		ПараметрыСтроки.Установить("Сотрудник",		Сотрудник);
		ПараметрыСтроки.Установить("Оклад",			Оклад);
		
	КонецЦикла;
	
	Если ПредыдущееПодразделение <> "" Тогда		//	Выгружаем объект
		УзелСсылки		=	1;
		СчДокументов	=	1 + СчДокументов;
		СписокПараметров.Установить("Комментарий",		"#Выгрузка данных из конфигурации ""Зарплата + Кадры"" (" + СчДокументов + ")");
		СписокПараметров.Установить("НачисленоИтого",	НачисленоИтого);
		ВыгрузитьПоПравилу( , , ИдПравила, УзелСсылки, СписокПараметров);
		
		XML_DOM			=	гXMLАнализатор.СоздатьДокумент();
		УзелПроведения	=	XML_DOM.СоздатьУзел(1, "ПровестиДокумент");
		УзелПроведения.ДобавитьПодчиненный(УзелСсылки);
	    УстановитьАтрибут(УзелПроведения,	"Правило", ИдПравила);
		ЗаписатьОбъектВФайл(УзелПроведения);
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ВидРасхода
Функция ПравилоРеквизита_ID1С_0009460(Источник, Приемник, СписокПараметровПравила)

	ВидРасходаИзСписка = СписокПараметровПравила.Получить("ВидРасхода");
	Если ТипЗначенияСтр(ВидРасходаИзСписка) <> "Строка" тогда
		Возврат ВидРасходаИзСписка;
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ВидРасхода
Функция ПравилоРеквизита_ID1С_0007542(Источник, Приемник, СписокПараметровПравила)

	ВидРасходаИзСписка = СписокПараметровПравила.Получить("ВидРасхода");
	Если ТипЗначенияСтр(ВидРасходаИзСписка) <> "Строка" тогда
		Возврат ВидРасходаИзСписка;
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ВидРасхода
Функция ПравилоРеквизита_ID1С_0007543(Источник, Приемник, СписокПараметровПравила)

	ВидРасходаИзСписка = СписокПараметровПравила.Получить("ВидРасхода");
	Если ТипЗначенияСтр(ВидРасходаИзСписка) = "Строка" тогда
	Возврат ВидРасходаИзСписка
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ВидРасхода
Функция ПравилоРеквизита_ID1С_0009461(Источник, Приемник, СписокПараметровПравила)

	ВидРасходаИзСписка = СписокПараметровПравила.Получить("ВидРасхода");
	Если ТипЗначенияСтр(ВидРасходаИзСписка) = "Строка" тогда
	Возврат ВидРасходаИзСписка
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ДатаДок
Функция ПравилоРеквизита_F43A000147(Источник, Приемник, СписокПараметровПравила)

	Возврат  Лев(СокрЛП(Источник.Код), 10);

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ДатаДок
Функция ПравилоРеквизита_F43A000116(Источник, Приемник, СписокПараметровПравила)

	Возврат ДатаПров;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  ДатаДок
Функция ПравилоРеквизита_F43A000123(Источник, Приемник, СписокПараметровПравила)

	Возврат ДатаПров;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  НомерДок
Функция ПравилоРеквизита_F43A000145(Источник, Приемник, СписокПараметровПравила)

	Возврат  Сред(СокрЛП(Источник.Код), 11, СтрДлина(СокрЛП(Источник.Код)) - 10);

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  Объект
Функция ПравилоРеквизита_ID1С_0018628(Источник, Приемник, СписокПараметровПравила)

	СписокОбъекта = СписокПараметровПравила.Получить("Объект");
		Если ТипЗначенияСтр(СписокОбъекта) = "СписокЗначений"  тогда
			
			СписокПараметровПравила.Установить("Наименование", "Расходы будущих периодов");
			СписокПараметровПравила.Установить("ДатаНачалаСписания", СписокОбъекта.Получить("ДатаНачалаСписания"));
			СписокПараметровПравила.Установить("ДатаОкончанияСписания", СписокОбъекта.Получить("ДатаОкончанияСписания"));
			СписокПараметровПравила.Установить("ДатаПризнанияРасхода", СписокОбъекта.Получить("ДатаПризнанияРасхода"));
			СписокПараметровПравила.Установить("Сумма", СписокОбъекта.Получить("Сумма"));
			СписокПараметровПравила.Установить("ВидРасхода", СписокОбъекта.Получить("ВидРасхода"));
			СписокПараметровПравила.Установить("ЭлементРасхода", СписокОбъекта.Получить("ЭлементРасхода"));
			СписокПараметровПравила.Установить("ВидНачисления", СписокОбъекта.Получить("ВидНачисления"));
			СписокПараметровПравила.Установить("СуммаЕСН_ФБ", СписокОбъекта.Получить("СуммаЕСН_ФБ"));
			СписокПараметровПравила.Установить("СуммаФСС", СписокОбъекта.Получить("СуммаФСС"));
			СписокПараметровПравила.Установить("СуммаФФОМС", СписокОбъекта.Получить("СуммаФФОМС"));
			СписокПараметровПравила.Установить("СуммаТФОМС", СписокОбъекта.Получить("СуммаТФОМС"));
			СписокПараметровПравила.Установить("СуммаПФР_страх", СписокОбъекта.Получить("СуммаПФР_страх"));
			СписокПараметровПравила.Установить("СуммаПФР_нак", СписокОбъекта.Получить("СуммаПФР_нак"));
			СписокПараметровПравила.Установить("СуммаФСС_НС", СписокОбъекта.Получить("СуммаФСС_НС"));
			СписокПараметровПравила.Установить("СтавкаЕСН_ФБ", СписокОбъекта.Получить("СтавкаЕСН_ФБ"));
			СписокПараметровПравила.Установить("СтавкаФСС", СписокОбъекта.Получить("СтавкаФСС"));
			СписокПараметровПравила.Установить("СтавкаФФОМС", СписокОбъекта.Получить("СтавкаФФОМС"));
			СписокПараметровПравила.Установить("СтавкаТФОМС", СписокОбъекта.Получить("СтавкаТФОМС"));
			СписокПараметровПравила.Установить("СтавкаПФР_страх", СписокОбъекта.Получить("СтавкаПФР_страх"));
			СписокПараметровПравила.Установить("СтавкаПФР_нак", СписокОбъекта.Получить("СтавкаПФР_нак"));
			СписокПараметровПравила.Установить("СтавкаФСС_НС", СписокОбъекта.Получить("СтавкаФСС_НС"));
			
			СписокПараметровПравила.Установить("Объект", СписокОбъекта.Получить("Объект"));
			
			Возврат "ЭлементСправочникаРасходыБудущихПериодов";
			
		КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  Объект
Функция ПравилоРеквизита_ID1С_0018602(Источник, Приемник, СписокПараметровПравила)

	СписокОбъекта = СписокПараметровПравила.Получить("Объект");
	Если ТипЗначенияСтр(СписокОбъекта) <> "СписокЗначений"  тогда
	Возврат СписокОбъекта;
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  Объект
Функция ПравилоРеквизита_ID1С_0018625(Источник, Приемник, СписокПараметровПравила)

	СписокОбъекта = СписокПараметровПравила.Получить("Объект");
	Если ТипЗначенияСтр(СписокОбъекта) <> "СписокЗначений"  тогда
	Возврат СписокОбъекта;
	КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------

//	-->  Объект
Функция ПравилоРеквизита_ID1С_0018626(Источник, Приемник, СписокПараметровПравила)

	СписокОбъекта = СписокПараметровПравила.Получить("Объект");
		Если ТипЗначенияСтр(СписокОбъекта) = "СписокЗначений"  тогда
			
			СписокПараметровПравила.Установить("Наименование", "Расходы будущих периодов");
			СписокПараметровПравила.Установить("ДатаНачалаСписания", СписокОбъекта.Получить("ДатаНачалаСписания"));
			СписокПараметровПравила.Установить("ДатаОкончанияСписания", СписокОбъекта.Получить("ДатаОкончанияСписания"));
			СписокПараметровПравила.Установить("ДатаПризнанияРасхода", СписокОбъекта.Получить("ДатаПризнанияРасхода"));
			СписокПараметровПравила.Установить("Сумма", СписокОбъекта.Получить("Сумма"));
			СписокПараметровПравила.Установить("ВидРасхода", СписокОбъекта.Получить("ВидРасхода"));
			СписокПараметровПравила.Установить("ЭлементРасхода", СписокОбъекта.Получить("ЭлементРасхода"));
			СписокПараметровПравила.Установить("ВидНачисления", СписокОбъекта.Получить("ВидНачисления"));
			СписокПараметровПравила.Установить("СуммаЕСН_ФБ", СписокОбъекта.Получить("СуммаЕСН_ФБ"));
			СписокПараметровПравила.Установить("СуммаФСС", СписокОбъекта.Получить("СуммаФСС"));
			СписокПараметровПравила.Установить("СуммаФФОМС", СписокОбъекта.Получить("СуммаФФОМС"));
			СписокПараметровПравила.Установить("СуммаТФОМС", СписокОбъекта.Получить("СуммаТФОМС"));
			СписокПараметровПравила.Установить("СуммаПФР_страх", СписокОбъекта.Получить("СуммаПФР_страх"));
			СписокПараметровПравила.Установить("СуммаПФР_нак", СписокОбъекта.Получить("СуммаПФР_нак"));
			СписокПараметровПравила.Установить("СуммаФСС_НС", СписокОбъекта.Получить("СуммаФСС_НС"));
			СписокПараметровПравила.Установить("СтавкаЕСН_ФБ", СписокОбъекта.Получить("СтавкаЕСН_ФБ"));
			СписокПараметровПравила.Установить("СтавкаФСС", СписокОбъекта.Получить("СтавкаФСС"));
			СписокПараметровПравила.Установить("СтавкаФФОМС", СписокОбъекта.Получить("СтавкаФФОМС"));
			СписокПараметровПравила.Установить("СтавкаТФОМС", СписокОбъекта.Получить("СтавкаТФОМС"));
			СписокПараметровПравила.Установить("СтавкаПФР_страх", СписокОбъекта.Получить("СтавкаПФР_страх"));
			СписокПараметровПравила.Установить("СтавкаПФР_нак", СписокОбъекта.Получить("СтавкаПФР_нак"));
			СписокПараметровПравила.Установить("СтавкаФСС_НС", СписокОбъекта.Получить("СтавкаФСС_НС"));
			
			СписокПараметровПравила.Установить("Объект", СписокОбъекта.Получить("Объект"));
			
			Возврат "ЭлементСправочникаРасходыБудущихПериодов";
			
		КонецЕсли;

	Возврат(0);

КонецФункции

//--------------------------------------------------------------------------------------------------


Функция ДополнительныеПреобразования(Вид="", Ид="", Источник="", Приемник="", СписокПараметровПравила="")

	Если Вид = "" Тогда

		Возврат(1);

	ИначеЕсли Вид = "Условие" Тогда

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "ID1С_0000523" Тогда
			Возврат Условие_ID1С_0000523(Источник, СписокПараметровПравила);	//	Есть вручную введенные данные в БЛ
		КонецЕсли;

	ИначеЕсли Вид = "ПравилоВыборкиОбъектов" Тогда

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "ВводОстатковНезавПроизв_F43A000055" Тогда
			Возврат ПравилоВыборкиОбъектов_ВводОстатковНезавПроизв_F43A000055(Ид);	//	-->  ВводОстатковНезавПроизв (Документ)
		ИначеЕсли Ид = "НачислениеЗП_F43A000053" Тогда
			Возврат ПравилоВыборкиОбъектов_НачислениеЗП_F43A000053(Ид);	//	-->  НачислениеЗП (Документ)
		КонецЕсли;

	ИначеЕсли Вид = "ПравилоРеквизита" Тогда

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "ID1С_0009460" Тогда
			Возврат ПравилоРеквизита_ID1С_0009460(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидРасхода
		ИначеЕсли Ид = "ID1С_0007542" Тогда
			Возврат ПравилоРеквизита_ID1С_0007542(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидРасхода
		ИначеЕсли Ид = "ID1С_0007543" Тогда
			Возврат ПравилоРеквизита_ID1С_0007543(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидРасхода
		ИначеЕсли Ид = "ID1С_0009461" Тогда
			Возврат ПравилоРеквизита_ID1С_0009461(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидРасхода
		ИначеЕсли Ид = "F43A000147" Тогда
			Возврат ПравилоРеквизита_F43A000147(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаДок
		ИначеЕсли Ид = "F43A000116" Тогда
			Возврат ПравилоРеквизита_F43A000116(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаДок
		ИначеЕсли Ид = "F43A000123" Тогда
			Возврат ПравилоРеквизита_F43A000123(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаДок
		ИначеЕсли Ид = "F43A000145" Тогда
			Возврат ПравилоРеквизита_F43A000145(Источник, Приемник, СписокПараметровПравила);	//	-->  НомерДок
		ИначеЕсли Ид = "ID1С_0018628" Тогда
			Возврат ПравилоРеквизита_ID1С_0018628(Источник, Приемник, СписокПараметровПравила);	//	-->  Объект
		ИначеЕсли Ид = "ID1С_0018602" Тогда
			Возврат ПравилоРеквизита_ID1С_0018602(Источник, Приемник, СписокПараметровПравила);	//	-->  Объект
		ИначеЕсли Ид = "ID1С_0018625" Тогда
			Возврат ПравилоРеквизита_ID1С_0018625(Источник, Приемник, СписокПараметровПравила);	//	-->  Объект
		ИначеЕсли Ид = "ID1С_0018626" Тогда
			Возврат ПравилоРеквизита_ID1С_0018626(Источник, Приемник, СписокПараметровПравила);	//	-->  Объект
		КонецЕсли;

	ИначеЕсли Вид = "ПравилоЗначения" Тогда

		Если Ид = "" Тогда
			Возврат(1);
		КонецЕсли;

	ИначеЕсли Вид = "ПравилоРеквизитаЗначения" Тогда

		Если Ид = "" Тогда
			Возврат(1);
		КонецЕсли;

	КонецЕсли;

	Возврат(0);

КонецФункции		//	ДополнительныеПреобразования()

//--------------------------------------------------------------------------------------------------

