Перем	ВыбАвтор;
Перем	ВыбПроект;
Перем	ВыбЮрЛицо;
Перем	ВыгружатьПартии;
Перем	ДеятельностьОблагаемаяНДС;

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

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

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

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

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

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

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

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

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

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

//--------------------------------------------------------------------------------------------------
                                                                                                    
Функция СоздатьПроводку(УзелОперации, СчетДт="", СчетКт="", Сумма="", Колво="", Валюта="", ВалСумма="", ТабРеквизитовПроводки="", ПланСчетов="", Сложная="")

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

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

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

КонецПроцедуры		//	ВыгрузитьСубконто()

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

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

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

Функция СоздатьТаблицуПроводок()
	
	Таб = СоздатьОбъект("ТаблицаЗначений");

	Таб.НоваяКолонка("ПланСчетов");
	Таб.НоваяКолонка("Сложная");
	
	Таб.НоваяКолонка("СчетДт");
	Таб.НоваяКолонка("СчетКт");
	Таб.НоваяКолонка("Сумма");
	Таб.НоваяКолонка("Количество");
	Таб.НоваяКолонка("Валюта");
	Таб.НоваяКолонка("ВалСумма");
	
	Таб.НоваяКолонка("ТабСубконтоДт");
	Таб.НоваяКолонка("ТабСубконтоКт");
	Таб.НоваяКолонка("ТабРеквизитовПроводки");
	
	Возврат Таб;
	
КонецФункции		//	СоздатьТаблицуРеквизитов()

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

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

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




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

	Иначе
		ОблагаетсяЕНВД = 0;
	КонецЕсли;

	ВидДеятельности = "Оптовая торговля";
	
	Если (глЕстьРеквизитШапки("Счет", Источник.Вид()) = 1) или (глЕстьРеквизитМнЧ("Счет", Источник.Вид()) = 1) Тогда
		Если Источник.Счет.Выбран() = 1 Тогда
			Код = Источник.Счет.Код;
			Субконто = Источник.Субконто1;
			
			Если (Код = "20") или (Код = "23") или (Код = "25") или (Код = "26") или (Код = "29") или (Код = "44.2") или (Код = "44.3") Тогда
				ВидДеятельности = "Оказание услуг";
				ИныеМатериальныеРасходы = 1;
				
			ИначеЕсли Код = "44.1.1" Тогда
				ВидДеятельности = "Оптовая торговля";
				ИныеМатериальныеРасходы = 1;
				
			ИначеЕсли Код = "44.1.2" Тогда
				ВидДеятельности = "Розничная торговля (ЕНВД)";
				ОблагаетсяЕНВД = 1;
				ИныеМатериальныеРасходы = 1;
				
			ИначеЕсли Код = "44.1.3" Тогда
				ВидДеятельности = "Оптовая торговля";
				ИныеМатериальныеРасходы = 1;
				
			ИначеЕсли Код = "90.2.1" Тогда
				ИныеМатериальныеРасходы = 1;
				
				Если Субконто.Выбран() = 1 Тогда
					Если СокрЛП(Субконто.Наименование) = "ПосредническаяУслуга" Тогда
						ВидДеятельности = "Деятельность агентов";
			
					ИначеЕсли СокрЛП(Субконто.Наименование) = "Товар" Тогда
						ВидДеятельности = "Оптовая торговля";
						
					Иначе
						ВидДеятельности = "Оказание услуг";
					КонецЕсли;
					
				Иначе
					ВидДеятельности = "Оптовая торговля";
				КонецЕсли;
				
			ИначеЕсли Код = "90.2.2" Тогда
				ОблагаетсяЕНВД = 1;
				ИныеМатериальныеРасходы = 1;
				Субконто = Источник.Субконто1;
				Если Субконто.Выбран() = 1 Тогда
					Если СокрЛП(Субконто.Наименование) = "Товар" Тогда
						ВидДеятельности = "Розничная торговля (ЕНВД)";
						
					Иначе
						ВидДеятельности = "Оказание услуг (ЕНВД)";
					КонецЕсли;
					
				Иначе
					ВидДеятельности = "Розничная торговля (ЕНВД)";
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
	Возврат ВидДеятельности;
	
КонецФункции

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

Функция Время_ЧислоВСтроку(ВсегоСекунд, БезСуток=1, ПредставлениеНуля="")
	
	Если ПустоеЗначение(ВсегоСекунд) = 1 Тогда Возврат(ПредставлениеНуля) КонецЕсли;
	
	Ч		=	Цел(ВсегоСекунд / 3600);
	М		=	Цел((ВсегоСекунд - Ч*3600) / 60);
	С		=	ВсегоСекунд - Ч*3600 - М*60;
	                                                
	Если БезСуток = 1 Тогда
		Ч	=	Ч - Цел(Ч/24)*24;
	КонецЕсли;
	
	Возврат ДополнитьНулями(Ч, 2) + ":" + ДополнитьНулями(М, 2) + ":" + ДополнитьНулями(С, 2);

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

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

Функция Время_ЧислоИзСтроки(Знач ВремяСтрока, Ч=0, М=0, С=0, ДополнятьСутками=0)
	  
	Если СокрЛП(СтрЗаменить(ВремяСтрока, ":", "")) = "" Тогда Возврат(0) КонецЕсли;
		
	Часы		=	СокрЛП(ВремяСтрока);
	Минуты		=	СокрЛП(ОтделитьРазделителем(Часы,	":"));
	Секунды		=	СокрЛП(ОтделитьРазделителем(Минуты,	":"));
	
	Если (Число(Часы) > 24) И (СтрДлина(Минуты) < 2) Тогда
		Минуты	=	Прав(Часы, 1) + Лев(Минуты,1);
		Часы	=	Лев(Часы, 1);
	ИначеЕсли Число(Часы) > 24 Тогда
		Возврат(0);
	ИначеЕсли Число(Часы) = 24 Тогда
		Часы	=	0;
	КонецЕсли;
	
	Ч			=	Число(Часы);
	М			=	Число(Минуты);
	С			=	Число(Секунды) + ?(Ч+М=0, 1, 0);	//	пустое значение означает ошибку
	                             
	ВсегоСекунд	=	Ч*3600 + М*60 + С;
	
	Если ДополнятьСутками = 1 Тогда
		Если ВсегоСекунд < 18000 Тогда	//	5 часов утра	// Не доделано - Это можно в константу или пользователя
			ВсегоСекунд = ВсегоСекунд + 86400;
		КонецЕсли;
	КонецЕсли;

	Возврат(ВсегоСекунд);	//	Время в секундах
	
КонецФункции

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

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

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

		Возврат(1);
		
	Иначе
		Возврат(0);
	КонецЕсли;

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

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

Функция НайтиПравилоДокумента(Источник, Правило="", ИдПравила="", ВидДокПриемника="")

	Запрос = "//Правило[(ОбъектИсточник/@Тип = ""Документ"")";
	Вид = Источник.Вид();
	Запрос = Запрос + "and(ОбъектИсточник/@Вид = """ + Вид + """)";
	Запрос = Запрос + "and(ОбъектПриемник/@Тип = ""Документ"")";
	Запрос = Запрос + "]";

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

	Возврат 0;

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

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

Функция ОблагаетсяНДС(Источник, ОблагаетсяЕНВД = 0)

	ВидДок = Источник.Вид();
	ЕстьСклад = глЕстьРеквизитШапки("Склад", ВидДок);                
	ЕстьОблагаетсяЕНВД = глЕстьРеквизитШапки("ОблагаетсяЕНВД", ВидДок);
	Склад = ?(ЕстьСклад = 1, Источник.Склад, "");
		
	Если ЕстьОблагаетсяЕНВД = 1 Тогда
	    ОблагаетсяЕНВД = Источник.ОблагаетсяЕНВД;
		
	ИначеЕсли ЕстьСклад = 1 Тогда
		ОблагаетсяЕНВД = Источник.Склад.ОблагаетсяЕНВД;
		
	Иначе
		ОблагаетсяЕНВД = 0;
	КонецЕсли;
	
	Если ОблагаетсяЕНВД = 1 Тогда
	    ОблагаетсяНДС = 0;
		
	Иначе
		ОблагаетсяНДС = ДеятельностьОблагаемаяНДС;
	КонецЕсли;

	Возврат ОблагаетсяНДС;

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

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

Функция ПлатежныйДокументПоСчетуФактуре(Источник)

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

	Возврат 0;

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

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

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

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

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

	ИначеЕсли Лев(Статус, 2) = "М_" Тогда
		Наименование = "ИныеМатериальныеРасходы";
		
	ИначеЕсли Лев(Статус, 2) = "П_" Тогда
		Наименование = "Товар";
		
	ИначеЕсли Номенклатура.ВидНоменклатуры = Перечисление.ВидыНоменклатуры.Услуга Тогда
		Наименование = "Услуга";
	
	Иначе
		Наименование = "Товар";
	КонецЕсли;
	
	Возврат Наименование;
	
КонецФункции

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

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

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

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

Функция ПредставлениеДокумента(Документ)
	
	Если (ТипЗначения(Документ)=12)
	и    (ПустоеЗначение(Документ)=0)
	Тогда   
		Представление = глНазваниеДокументаВЖурнале(Документ);
		Представление = Представление + " № " + СокрЛП(Документ.НомерДок) 
			+ " от " + Документ.ДатаДок; 
		Если глЕстьРеквизитШапки("НомерДокВходящий", Документ.Вид()) = 1 тогда
			
			Если ПустоеЗначение(Документ.НомерДокВходящий) = 0 Тогда
			    Представление = Представление + " (вх. № " + СокрЛП(Документ.НомерДокВходящий) +
				                                " от " + Документ.ДатаДокВходящий + ")";
			КонецЕсли;
		КонецЕсли;
		Возврат Представление;
	КонецЕсли;
	Возврат ""
	
КонецФункции

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

Функция ПреобразоватьСтавкуНДС(СтавкаНДС)
    
    Если СтавкаНДС = Перечисление.СтавкиНДС.НДС9_09 Тогда
		Возврат "НДС10_110";
		
	ИначеЕсли СтавкаНДС = Перечисление.СтавкиНДС.НДС16_67 Тогда
		Возврат "НДС20_120";
		
	Иначе
        Возврат СтавкаНДС.Идентификатор();
	КонецЕсли;

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

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

Функция РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, ЭтоПриход, ТолькоТовары = 0)

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

	ЕстьНоменклатура = глЕстьРеквизитМнЧ("Номенклатура", ВидДок);
	ЕстьГТД = глЕстьРеквизитМнЧ("ГТД", ВидДок);
	ЕстьСтавкаНДС = глЕстьРеквизитМнЧ("СтавкаНДС", ВидДок);
	ЕстьСтавкаНП = глЕстьРеквизитМнЧ("СтавкаНП", ВидДок);
	ЕстьКоличество = глЕстьРеквизитМнЧ("Количество", ВидДок);
	ЕстьСумма= глЕстьРеквизитМнЧ("Сумма", ВидДок);
	ЕстьСуммаНДС = глЕстьРеквизитМнЧ("СуммаНДС", ВидДок);
	ЕстьСуммаНП = глЕстьРеквизитМнЧ("СуммаНП", ВидДок);
	ЕстьЦена = глЕстьРеквизитМнЧ("Цена", ВидДок);
	ЕстьКоэффициент = глЕстьРеквизитМнЧ("Коэффициент", ВидДок);
	
	ЕстьСклад = глЕстьРеквизитШапки("Склад", ВидДок);
	ЕстьОблагаетсяЕНВД = глЕстьРеквизитШапки("ОблагаетсяЕНВД", ВидДок);
	
	Если ВидПриемника = "ПеремещениеМатериальныхРесурсов" Тогда
		ЕстьСуммаНДС = 0;
	    ЕстьСуммаНП = 0;
	    ЕстьСтавкаНДС = 0;
		ЕстьСтавкаНП = 0;
		ЕстьЦена = 0;
	КонецЕсли;	
	
	Склад = ?(ЕстьСклад = 1, Источник.Склад, "");

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

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

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

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

	ТаблицаДокументаИсточника.ВыбратьСтроки();
	Пока ТаблицаДокументаИсточника.ПолучитьСтроку() = 1 Цикл
		Если ЕстьСумма = 1 Тогда
			Если ТаблицаДокументаИсточника.Сумма <> ТаблицаДокументаИсточника.РаспредСумма Тогда
				НомСтроки = 0;
			    Если ТаблицаДокумента.НайтиЗначение(ТаблицаДокументаИсточника.НомерСтроки, НомСтроки, "НомСтрокиИсточника") = 1 Тогда
				    ТаблицаДокумента.ПолучитьСтрокуПоНомеру(НомСтроки);
					ТаблицаДокумента.Сумма = ТаблицаДокумента.Сумма + ТаблицаДокументаИсточника.Сумма - ТаблицаДокументаИсточника.РаспредСумма;
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		Если ЕстьСуммаНДС = 1 Тогда
			Если ТаблицаДокументаИсточника.СуммаНДС <> ТаблицаДокументаИсточника.РаспредСуммаНДС Тогда
				НомСтроки = 0;
				Если ТаблицаДокумента.НайтиЗначение(ТаблицаДокументаИсточника.НомерСтроки, НомСтроки, "НомСтрокиИсточника") = 1 Тогда
				    ТаблицаДокумента.ПолучитьСтрокуПоНомеру(НомСтроки);
					ТаблицаДокумента.СуммаНДС = ТаблицаДокумента.СуммаНДС + ТаблицаДокументаИсточника.СуммаНДС - ТаблицаДокументаИсточника.РаспредСуммаНДС;
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		Если ЕстьСуммаНП = 1 Тогда
			Если ТаблицаДокументаИсточника.СуммаНП <> ТаблицаДокументаИсточника.РаспредСуммаНП Тогда
				НомСтроки = 0;
				Если ТаблицаДокумента.НайтиЗначение(ТаблицаДокументаИсточника.НомерСтроки, НомСтроки, "НомСтрокиИсточника") = 1 Тогда
				    ТаблицаДокумента.ПолучитьСтрокуПоНомеру(НомСтроки);
					ТаблицаДокумента.СуммаНП = ТаблицаДокумента.СуммаНП + ТаблицаДокументаИсточника.СуммаНП - ТаблицаДокументаИсточника.РаспредСуммаНП;
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;

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

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

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

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

	Правило = гПравила.ВыбратьУзел("//Правило[@Ид = ""ВидыДеятельности_PBU_000049""]");
	ВыгрузитьРеквизит(Приемник, ИмяПриемника,,, "Справочник", "ВидыДеятельности", Правило, СписокПараметров);
	
КонецПроцедуры

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


//	Есть иные или не принимаемые расходы
Функция Условие_PBU_000017(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	ИныеРасходы = 0;
	Объект.ВыбратьСтроки();
	Пока Объект.ПолучитьСтроку() = 1 Цикл
		Если Объект.Счет.Выбран() = 1 Тогда
			Если (Объект.Счет.Код = "01.1") или
				 (Объект.Счет.Код = "01.2") или
				 (Объект.Счет.Код = "03.1") или
				 (Объект.Счет.Код = "03.2") или
				 (Объект.Счет.Код = "03.3") или
				 (Объект.Счет.Код = "03.4") или
				 (Объект.Счет.Код = "03.5") или
				 (Объект.Счет.Код = "04") или
				 (Объект.Счет.Код = "07") или
				 (Объект.Счет.Код = "08.1") или
				 (Объект.Счет.Код = "08.2") или
				 (Объект.Счет.Код = "08.3") или
				 (Объект.Счет.Код = "08.4") или
				 (Объект.Счет.Код = "08.5") или
				 (Объект.Счет.Код = "08.6") или
				 (Объект.Счет.Код = "08.7") или
				 (Объект.Счет.Код = "20") или
				 (Объект.Счет.Код = "23") или
				 (Объект.Счет.Код = "25") или
				 (Объект.Счет.Код = "26") или
				 (Объект.Счет.Код = "29") или
				 (Объект.Счет.Код = "44.1.1") или
				 (Объект.Счет.Код = "44.1.2") или
				 (Объект.Счет.Код = "44.1.3") или
				 (Объект.Счет.Код = "44.2") или
				 (Объект.Счет.Код = "44.3") или
				 (Объект.Счет.Код = "90.2.1") или
				 (Объект.Счет.Код = "90.2.2") Тогда
				
				ИныеРасходы = 1; 
				Прервать;
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;
	
	Возврат ИныеРасходы;

	Возврат(0);

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

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

//	Есть иные расходы
Функция Условие_PBU_000021(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	ИныеРасходы = 0;
	Объект.ВыбратьСтроки();
	Пока Объект.ПолучитьСтроку() = 1 Цикл
		Если Объект.Счет.Выбран() = 1 Тогда
			Если (Объект.Счет.Код = "20") или
				 (Объект.Счет.Код = "23") или
				 (Объект.Счет.Код = "25") или
				 (Объект.Счет.Код = "26") или
				 (Объект.Счет.Код = "29") или
				 (Объект.Счет.Код = "44.1.1") или
				 (Объект.Счет.Код = "44.1.2") или
				 (Объект.Счет.Код = "44.1.3") или
				 (Объект.Счет.Код = "44.2") или
				 (Объект.Счет.Код = "44.3") или
				 (Объект.Счет.Код = "90.2.1") или
				 (Объект.Счет.Код = "90.2.2") Тогда
				
				ИныеРасходы = 1; 
				Прервать;
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;
	
	Возврат ИныеРасходы;

	Возврат(0);

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

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

//	Есть прочие расходы
Функция Условие_PBU_000019(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	ПрочиеРасходы = 0;
	Объект.ВыбратьСтроки();
	Пока Объект.ПолучитьСтроку() = 1 Цикл
		Если Объект.Счет.Выбран() = 1 Тогда
			Если (Объект.Счет.Код <> "01.1") и
				 (Объект.Счет.Код <> "01.2") и
				 (Объект.Счет.Код <> "03.1") и
				 (Объект.Счет.Код <> "03.2") и
				 (Объект.Счет.Код <> "03.3") и
				 (Объект.Счет.Код <> "03.4") и
				 (Объект.Счет.Код <> "03.5") и
				 (Объект.Счет.Код <> "04") и
				 (Объект.Счет.Код <> "07") и
				 (Объект.Счет.Код <> "08.1") и
				 (Объект.Счет.Код <> "08.2") и
				 (Объект.Счет.Код <> "08.3") и
				 (Объект.Счет.Код <> "08.4") и
				 (Объект.Счет.Код <> "08.5") и
				 (Объект.Счет.Код <> "08.6") и
				 (Объект.Счет.Код <> "08.7") и
				 (Объект.Счет.Код <> "20") и
				 (Объект.Счет.Код <> "23") и
				 (Объект.Счет.Код <> "25") и
				 (Объект.Счет.Код <> "26") и
				 (Объект.Счет.Код <> "29") и
				 (Объект.Счет.Код <> "44.1.1") и
				 (Объект.Счет.Код <> "44.1.2") и
				 (Объект.Счет.Код <> "44.1.3") и
				 (Объект.Счет.Код <> "44.2") и
				 (Объект.Счет.Код <> "44.3") и
				 (Объект.Счет.Код <> "90.2.1") и
				 (Объект.Счет.Код <> "90.2.2") Тогда
				
				ПрочиеРасходы = 1; 
				Прервать;
			КонецЕсли;
		КонецЕсли;
	КонецЦикла;
	
	Возврат ПрочиеРасходы;

	Возврат(0);

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

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

//	Есть табличная часть
Функция Условие_PBU_000004(Объект, ИдПравила)

	Если Объект.КоличествоСтрок() > 0 Тогда Возврат(1) КонецЕсли;

	Возврат(0);

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

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

//	(ЕстьСчетФактура = 0) и (Ввод остатков = 0)
Функция Условие_PBU_000003(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(Объект.ДокОснование) = 1 Тогда
		Возврат 1;
	
	ИначеЕсли Объект.ДокОснование.Вид() = "ВводОстатковПоставщика" Тогда
		Возврат 0;
	
	ИначеЕсли Объект.ДокОснование.ДатаДок <> Объект.ДатаДок Тогда
		Возврат 1;
	КонецЕсли;

	Возврат(0);

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

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

//	Изм. вид деятельности
Функция Условие_PBU_000024(Объект, ИдПравила)

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

	Возврат(0);

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

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

//	Иной или не принимаемый расход
Функция Условие_PBU_000018(Объект, ИдПравила)

	ИныеРасходы = 0;
	
	Если Объект.Счет.Выбран() = 1 Тогда
		Если (Объект.Счет.Код = "01.1") или
			 (Объект.Счет.Код = "01.2") или
			 (Объект.Счет.Код = "03.1") или
			 (Объект.Счет.Код = "03.2") или
			 (Объект.Счет.Код = "03.3") или
			 (Объект.Счет.Код = "03.4") или
			 (Объект.Счет.Код = "03.5") или
			 (Объект.Счет.Код = "04") или
			 (Объект.Счет.Код = "07") или
			 (Объект.Счет.Код = "08.1") или
			 (Объект.Счет.Код = "08.2") или
			 (Объект.Счет.Код = "08.3") или
			 (Объект.Счет.Код = "08.4") или
			 (Объект.Счет.Код = "08.5") или
			 (Объект.Счет.Код = "08.6") или
			 (Объект.Счет.Код = "08.7") или
			 (Объект.Счет.Код = "20") или
			 (Объект.Счет.Код = "23") или
			 (Объект.Счет.Код = "25") или
			 (Объект.Счет.Код = "26") или
			 (Объект.Счет.Код = "29") или
			 (Объект.Счет.Код = "44.1.1") или
			 (Объект.Счет.Код = "44.1.2") или
			 (Объект.Счет.Код = "44.1.3") или
			 (Объект.Счет.Код = "44.2") или
			 (Объект.Счет.Код = "44.3") или
			 (Объект.Счет.Код = "90.2.1") или
			 (Объект.Счет.Код = "90.2.2") Тогда
			
			ИныеРасходы = 1; 
		КонецЕсли;
	КонецЕсли;
	
	Возврат ИныеРасходы;

	Возврат(0);

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

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

//	Иной расход
Функция Условие_PBU_000022(Объект, ИдПравила)

	ИныеРасходы = 0;
	
	Если Объект.Счет.Выбран() = 1 Тогда
		Если (Объект.Счет.Код = "20") или
			 (Объект.Счет.Код = "23") или
			 (Объект.Счет.Код = "25") или
			 (Объект.Счет.Код = "26") или
			 (Объект.Счет.Код = "29") или
			 (Объект.Счет.Код = "44.1.1") или
			 (Объект.Счет.Код = "44.1.2") или
			 (Объект.Счет.Код = "44.1.3") или
			 (Объект.Счет.Код = "44.2") или
			 (Объект.Счет.Код = "44.3") или
			 (Объект.Счет.Код = "90.2.1") или
			 (Объект.Счет.Код = "90.2.2") Тогда
			
			ИныеРасходы = 1; 
		КонецЕсли;
	КонецЕсли;
	
	Возврат ИныеРасходы;

	Возврат(0);

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

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

//	Комплектация
Функция Условие_PBU_000009(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если Объект.КодОперации = Перечисление.КодыОпераций.Сборка Тогда
		Возврат(1);
	КонецЕсли;

	Возврат(0);

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

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

//	Ввод остатков = 0
Функция Условие_PBU_000016(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(Объект.ДокОснование) = 1 Тогда
		Возврат 1;
	
	ИначеЕсли Объект.ДокОснование.Вид() = "ВводОстатковПокупателя" Тогда
		Возврат 0;
	КонецЕсли;
	
	Возврат 1;

	Возврат(0);

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

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

//	Не принимаемые расход
Функция Условие_PBU_000023(Объект, ИдПравила)

	ИныеРасходы = 0;
	
	Если Объект.Счет.Выбран() = 1 Тогда
		Если (Объект.Счет.Код = "01.1") или
			 (Объект.Счет.Код = "01.2") или
			 (Объект.Счет.Код = "03.1") или
			 (Объект.Счет.Код = "03.2") или
			 (Объект.Счет.Код = "03.3") или
			 (Объект.Счет.Код = "03.4") или
			 (Объект.Счет.Код = "03.5") или
			 (Объект.Счет.Код = "04") или
			 (Объект.Счет.Код = "07") или
			 (Объект.Счет.Код = "08.1") или
			 (Объект.Счет.Код = "08.2") или
			 (Объект.Счет.Код = "08.3") или
			 (Объект.Счет.Код = "08.4") или
			 (Объект.Счет.Код = "08.5") или
			 (Объект.Счет.Код = "08.6") или
			 (Объект.Счет.Код = "08.7") Тогда
			 		
			ИныеРасходы = 1; 
		КонецЕсли;
	КонецЕсли;
	
	Возврат ИныеРасходы;

	Возврат(0);

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

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

//	Свой р/с
Функция Условие_ID1С_0001006(Объект, ИдПравила)

	Если Объект.ЮрФизЛицо.Вид() = "СвоиЮрЛица" Тогда
		Возврат 1;
	КонецЕсли;

	Возврат(0);

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

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

//	Отбор документов
Функция Условие_PBU_000008(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Возврат 1;

	Возврат(0);

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

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

//	Прочий расход
Функция Условие_PBU_000020(Объект, ИдПравила)

	ПрочиеРасходы = 0;
	
	Если Объект.Счет.Выбран() = 1 Тогда
		Если (Объект.Счет.Код <> "01.1") и
			 (Объект.Счет.Код <> "01.2") и
			 (Объект.Счет.Код <> "03.1") и
			 (Объект.Счет.Код <> "03.2") и
			 (Объект.Счет.Код <> "03.3") и
			 (Объект.Счет.Код <> "03.4") и
			 (Объект.Счет.Код <> "03.5") и
			 (Объект.Счет.Код <> "04") и
			 (Объект.Счет.Код <> "07") и
			 (Объект.Счет.Код <> "08.1") и
			 (Объект.Счет.Код <> "08.2") и
			 (Объект.Счет.Код <> "08.3") и
			 (Объект.Счет.Код <> "08.4") и
			 (Объект.Счет.Код <> "08.5") и
			 (Объект.Счет.Код <> "08.6") и
			 (Объект.Счет.Код <> "08.7") и
			 (Объект.Счет.Код <> "20") и
			 (Объект.Счет.Код <> "23") и
			 (Объект.Счет.Код <> "25") и
			 (Объект.Счет.Код <> "26") и
			 (Объект.Счет.Код <> "29") и
			 (Объект.Счет.Код <> "44.1.1") и
			 (Объект.Счет.Код <> "44.1.2") и
			 (Объект.Счет.Код <> "44.1.3") и
			 (Объект.Счет.Код <> "44.2") и
			 (Объект.Счет.Код <> "44.3") и
			 (Объект.Счет.Код <> "90.2.1") и
			 (Объект.Счет.Код <> "90.2.2") Тогда
			
			ПрочиеРасходы = 1; 
		КонецЕсли;
	КонецЕсли;
	
	Возврат ПрочиеРасходы;

	Возврат(0);

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

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

//	Р/с контрагента
Функция Условие_ID1С_0001007(Объект, ИдПравила)

	Если Объект.ЮрФизЛицо.Вид() <> "СвоиЮрЛица" Тогда
		Возврат 1;
	КонецЕсли;

	Возврат(0);

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

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

//	Разукомплектация
Функция Условие_PBU_000010(Объект, ИдПравила)

	Если ПустоеЗначение(ВыбЮрЛицо) = 0 Тогда
		Если ВыбЮрЛицо <> Объект.ЮрЛицо Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбПроект) = 0 Тогда
		Если ВыбПроект <> Объект.Проект Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если ПустоеЗначение(ВыбАвтор) = 0 Тогда
		Если ВыбАвтор <> Объект.Автор Тогда Возврат(0) КонецЕсли;
	КонецЕсли;
	
	Если Объект.КодОперации = Перечисление.КодыОпераций.Разукомплектация Тогда
		Возврат(1);
	КонецЕсли;

	Возврат(0);

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

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

//	Уровень группы > 1
Функция Условие_ID1С_0001010(Объект, ИдПравила)

	Выгружать = 1;
	Если Объект.ЭтоГруппа() = 1 Тогда
		Если Объект.Уровень() > 1 Тогда
			Выгружать = 0;
		КонецЕсли;
	КонецЕсли;
	Возврат Выгружать;

	Возврат(0);

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

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

//	Уровень группы > 2
Функция Условие_ID1С_0001008(Объект, ИдПравила)

	Выгружать = 1;
	Если Объект.ЭтоГруппа() = 1 Тогда
		Если Объект.Уровень() > 2 Тогда
			Выгружать = 0;
		КонецЕсли;
	КонецЕсли;
	Возврат Выгружать;

	Возврат(0);

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

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

//	Уровень группы > 2
Функция Условие_ID1С_0001009(Объект, ИдПравила)

	Выгружать = 1;
	Если Объект.ЭтоГруппа() = 1 Тогда
		Если Объект.Уровень() > 2 Тогда
			Выгружать = 0;
		КонецЕсли;
	КонецЕсли;
	Возврат Выгружать;

	Возврат(0);

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

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

//	Уровень группы > 2
Функция Условие_ID1С_0001011(Объект, ИдПравила)

	Выгружать = 1;
	Если Объект.ЭтоГруппа() = 1 Тогда
		Если Объект.Уровень() > 2 Тогда
			Выгружать = 0;
		КонецЕсли;
	КонецЕсли;
	Возврат Выгружать;

	Возврат(0);

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

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

//	Разукомплектация
Функция ПравилоВыборкиОбъектов_ID_PBU_000243(ИдПравила)

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

	Возврат(0);

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

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

//	Перед началом выгрузки
Функция ПравилоВыборкиОбъектов_ID_PBU_000047(ИдПравила)

	ВыбЮрЛицо		=	гСписокПараметров.Получить("ВыбЮрЛицо");
	ВыбПроект		=	гСписокПараметров.Получить("ВыбПроект");
	ВыбАвтор		=	гСписокПараметров.Получить("ВыбАвтор");
	ДеятельностьОблагаемаяНДС	=	гСписокПараметров.Получить("ДеятельностьОблагаемаяНДС");
	ВыгружатьПартии	=	гСписокПараметров.Получить("ВыгружатьПартии");

	Возврат(0);

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

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

//	Списание
Функция ПравилоВыборкиОбъектов_ID_PBU_002649(ИдПравила)

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

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0, 1);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	Возврат ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 1);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 1);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 1);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");
	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 1);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

	РаспределитьСтрокиИсточникаПоПартиям(Источник, Приемник, 0);
	Возврат "#Прервать";

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
	ВыгрузитьРеквизит(Эл_Строка, "ВидМатериальногоРесурса", "ИныеРасходыРаспределяемые");
	ВыгрузитьРеквизит(Эл_Строка, "Номенклатура",,, "Справочник", "Номенклатура", "Таможенная_пошлина");
	ВыгрузитьРеквизит(Эл_Строка, "СтавкаНДС", "НДС20");
	ВыгрузитьРеквизит(Эл_Строка, "Сумма", Источник.Итог("СуммаПошлиныРуб"));
	ВыгрузитьРеквизит(Эл_Строка, "СуммаНДС", Источник.Итог("СуммаНДСРуб"));
	
	Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
	ВыгрузитьРеквизит(Эл_Строка, "ВидМатериальногоРесурса", "ИныеРасходыРаспределяемые");
	ВыгрузитьРеквизит(Эл_Строка, "Номенклатура",,, "Справочник", "Номенклатура", "Таможенный_сбор");
	ВыгрузитьРеквизит(Эл_Строка, "СтавкаНДС", "БезНДС");
	ВыгрузитьРеквизит(Эл_Строка, "Сумма", Источник.ТаможенныйСборРуб + глПересчет(Источник.ТаможенныйСборВал, Источник.Валюта, Источник.Курс, глРубли, 1));

	Возврат(0);

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

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

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

	Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
	ВыгрузитьРеквизит(Эл_Строка, "ВидМатериальногоРесурса", "ИныеРасходыРаспределяемые");
	ВыгрузитьРеквизит(Эл_Строка, "Номенклатура",,, "Справочник", "Номенклатура", "Таможенная_пошлина");
	ВыгрузитьРеквизит(Эл_Строка, "Поставка",, Источник, "Документ", "ПоступлениеТМЦ", "Поступление_Импорт");
	ВыгрузитьРеквизит(Эл_Строка, "ДокументПоступления",, Источник, "Документ", "ПоступлениеТМЦ", "Поступление_Таможня");
	
	Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
	ВыгрузитьРеквизит(Эл_Строка, "ВидМатериальногоРесурса", "ИныеРасходыРаспределяемые");
	ВыгрузитьРеквизит(Эл_Строка, "Номенклатура",,, "Справочник", "Номенклатура", "Таможенный_сбор");
	ВыгрузитьРеквизит(Эл_Строка, "Поставка",, Источник, "Документ", "ПоступлениеТМЦ", "Поступление_Импорт");
	ВыгрузитьРеквизит(Эл_Строка, "ДокументПоступления",, Источник, "Документ", "ПоступлениеТМЦ", "Поступление_Таможня");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	ВыгрузитьСуммовыеРазницы(Источник, "КорректировкаЗадолженности_PBU_000163");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	РегКнигаПродаж = СоздатьОбъект("Регистр.КнигаПродаж");
	ИтогСуммаНДС  = 0;
	ИтогВсегоСНДС = 0;
	
	РегКнигаПродаж.ВыбратьДвиженияДокумента(Источник);
	Пока РегКнигаПродаж.ПолучитьДвижение() = 1 Цикл
		Если РегКнигаПродаж.Приход = 1 Тогда
			ИтогСуммаНДС   = ИтогСуммаНДС   + РегКнигаПродаж.СуммаНДС;
			ИтогВсегоСНДС = ИтогВсегоСНДС + РегКнигаПродаж.СуммаРуб;
		КонецЕсли;
	КонецЦикла;
	
	Эл_Строка	=	Приемник.СоздатьПодчиненныйЭлемент("Строка");
	Правило = гПравила.ВыбратьУзел("//Правило[@Ид = ""Номенклатура_PBU_000177""]");
	ВыгрузитьРеквизит(Эл_Строка, "Номенклатура",,, "Справочник", "Номенклатура", Правило);
	ВыгрузитьРеквизит(Эл_Строка, "Сумма", ИтогВсегоСНДС);
	ВыгрузитьРеквизит(Эл_Строка, "СуммаНДС", ИтогСуммаНДС);
	СформироватьВидДеятельности(,, Эл_Строка, "ВидДеятельности", "Деятельность агентов", 0);
	ВыгрузитьРеквизит(Эл_Строка, "ВидМатериальногоРесурса", "Услуга");
	ВыгрузитьРеквизит(Эл_Строка, "СтавкаНДС", "НДС20_120");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПокупки.Валюта;

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПродажи.Валюта;

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.Склад, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельности");

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.Склад, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельности");

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.Склад, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельности");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.Склад, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельности");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.Склад, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельности");

	Возврат(0);

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

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

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

	ОблагаетсяЕНВД = 0;
	Наименование = ВидДеятельностиПоСчету(Источник, ОблагаетсяЕНВД);
	СформироватьВидДеятельности(,, Приемник, "ВидДеятельности", Наименование, ОблагаетсяЕНВД);

	Возврат(0);

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

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

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

	ОблагаетсяЕНВД = 0;
	Наименование = ВидДеятельностиПоСчету(Источник, ОблагаетсяЕНВД);
	СформироватьВидДеятельности(,, Приемник, "ВидДеятельности", Наименование, ОблагаетсяЕНВД);

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	СформироватьВидДеятельности(Источник.СкладПолучатель, Перечисление.СтатусыПартии.Т_Купленный, Приемник, "ВидДеятельностиКон");

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат глПредставлениеСФ(Источник.ДокОснование);

	Возврат(0);

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

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

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

	Возврат глПредставлениеСФ(Источник.ДокОснование);

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат глПредставлениеСФ(Источник);

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Если ПустоеЗначение(Источник.ДокОснование) = 0 Тогда
		Если ПустоеЗначение(Источник.ДокОснование.ДокОснование) = 0 Тогда
			Возврат Источник.ДокОснование.ДокОснование.ДатаДок;
		КонецЕсли;
	КонецЕсли;
	
	Возврат Дата(0);

	Возврат(0);

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

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

//	-->  ДокументПодтверждающийФактОплаты
Функция ПравилоРеквизита_PBU_001034(Источник, Приемник, СписокПараметровПравила)

	Возврат ПлатежныйДокументПоСчетуФактуре(Источник);

	Возврат(0);

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

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

//	-->  ДокументПодтверждающийФактОплаты
Функция ПравилоРеквизита_PBU_001063(Источник, Приемник, СписокПараметровПравила)

	Основание = Источник.ДокОснование;
	Если ПустоеЗначение(Основание) = 0 Тогда
		Если Основание.Вид() = "ПлатежноеПоручение" Тогда
			Возврат Основание;
		КонецЕсли;
	КонецЕсли;

	Возврат(0);

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

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

//	-->  ДокументПодтверждающийФактОплаты
Функция ПравилоРеквизита_PBU_003141(Источник, Приемник, СписокПараметровПравила)

	Возврат Источник.НомерДокВходящий + " от " + Источник.ДатаДокВходящий;

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Если Источник.ЮрФизЛицо.Вид() = "ФизЛица" Тогда
	    Возврат Источник.ЮрФизЛицо.ДокументУдЛичность;
		
	Иначе
		Возврат "";
	КонецЕсли;

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат глРубли.Код;

	Возврат(0);

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

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

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

	Возврат Источник.КоличествоКомп*Источник.КоэффициентКомп;

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат Источник.Счет.Код;

	Возврат(0);

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

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

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

	Возврат Источник.Счет.Код;

	Возврат(0);

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

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

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

	Если Источник.ОблагаетсяНП = 0 Тогда
		НП = 0;
	Иначе
		РасчетнаяСтавкаНП = Источник.СтавкаНП.Ставка/(100+Источник.СтавкаНП.Ставка);
		НП = Источник.Сумма*РасчетнаяСтавкаНП;
	КонецЕсли;
	
	СуммаБезНП = Источник.Сумма - НП;
	НДС = СуммаБезНП*глВыделяемыйНДС(Источник.СтавкаНДС);
	
	Возврат НДС;

	Возврат(0);

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

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

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

	СуммаБезНП = Источник.Сумма;
	НДС = СуммаБезНП*глВыделяемыйНДС(Источник.СтавкаНДС);
	
	Возврат НДС;

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "Б", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "М", 8, "Справа");

	Возврат(0);

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

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

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

	Если Источник.ОблагаетсяНП = 0 Тогда
		НП = 0;
	Иначе
		РасчетнаяСтавкаНП = Источник.СтавкаНП.Ставка/(100+Источник.СтавкаНП.Ставка);
		НП = Источник.Сумма*РасчетнаяСтавкаНП;
	КонецЕсли;
	
	Возврат НП;

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	МХ = Источник.Склад;
	
	Если МХ.ОблагаетсяЕНВД = 1 Тогда
		Возврат 0;
		
	Иначе
		Возврат ДеятельностьОблагаемаяНДС;
	КонецЕсли;

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	МХ = Источник.СкладПолучатель;
	
	Если МХ.ОблагаетсяЕНВД = 1 Тогда
		Возврат 0;
		
	Иначе
		Возврат ДеятельностьОблагаемаяНДС;
	КонецЕсли;

	Возврат(0);

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

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

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

	ПоДокументу = "";
	Если (Источник.КодОперации = глКО.ОплатаПоставщику) ИЛИ
	     (Источник.КодОперации = глКО.ВозвратОплатыПокупателю) Тогда
		 	
		Если Источник.Контрагент.ЮрФизЛицо.Вид() = "ФизЛица" Тогда
			ПоДокументу	= глПредставлениеУдостоверения(Источник.Контрагент.ЮрФизЛицо.ДокументУдЛичность);
		КонецЕсли;
	ИначеЕсли (Источник.КодОперации = глКО.ВыдачаПодотчет) Тогда
		
		ПоДокументу	= глПредставлениеУдостоверения(Источник.ФизЛицо.ДокументУдЛичность);
	Иначе
		Если ТипЗначенияСтр(Источник.Субконто1) = "Справочник" Тогда
			Если Источник.Субконто1.Вид() = "ФизЛица" Тогда
				ПоДокументу		= глПредставлениеУдостоверения(Источник.Субконто1.ДокументУдЛичность); 
			ИначеЕсли Источник.Субконто1.Вид() = "Контрагенты" Тогда
				Если Источник.Субконто1.ЮрФизЛицо.Вид() = "ФизЛица" Тогда
					ПоДокументу	= глПредставлениеУдостоверения(Источник.Субконто1.ЮрФизЛицо.ДокументУдЛичность); 
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		Если (ПустоеЗначение(ПоДокументу) = 1) и (ТипЗначенияСтр(Источник.Субконто2) = "Справочник") Тогда
			Если Источник.Субконто2.Вид() = "ФизЛица" Тогда
				ПоДокументу		= глПредставлениеУдостоверения(Источник.Субконто2.ДокументУдЛичность);
			ИначеЕсли Источник.Субконто2.Вид() = "Контрагенты" Тогда
				Если Источник.Субконто2.ЮрФизЛицо.Вид() = "ФизЛица" Тогда
					ПоДокументу	= глПредставлениеУдостоверения(Источник.Субконто2.ЮрФизЛицо.ДокументУдЛичность); 
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
		Если (ПустоеЗначение(ПоДокументу) = 1) и (ТипЗначенияСтр(Источник.Субконто3) = "Справочник") Тогда
			Если Источник.Субконто3.Вид() = "ФизЛица" Тогда
				ПоДокументу		= глПредставлениеУдостоверения(Источник.Субконто3.ДокументУдЛичность);
			ИначеЕсли Источник.Субконто1.Вид() = "Контрагенты" Тогда
				Если Источник.Субконто1.ЮрФизЛицо.Вид() = "ФизЛица" Тогда
					ПоДокументу	= глПредставлениеУдостоверения(Источник.Субконто3.ЮрФизЛицо.ДокументУдЛичность); 
				КонецЕсли;
			КонецЕсли;
		КонецЕсли;
	КонецЕсли;
	
	Возврат ПоДокументу;

	Возврат(0);

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

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

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

	Возврат Источник.ЮрФизЛицо.ПолнНаименование;

	Возврат(0);

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

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

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

	Возврат Источник.ЮрФизЛицо.ФактАдрес;

	Возврат(0);

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

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

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

	ТипЦены = глПользователь.ОсновнойТипЦенПокупки;
	ЦенаЦены = 0;
	глВернутьЦену(Источник, ТипЦены, ФормДатаКон, ЦенаЦены);
	Возврат ЦенаЦены;

	Возврат(0);

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

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

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

	Возврат ?(Источник.Сумма < 0, - Источник.Сумма, Источник.Сумма);

	Возврат(0);

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

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

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

	Возврат Источник.Сумма - Источник.СуммаНДС - Источник.СуммаНП;

	Возврат(0);

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

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

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

	Возврат Источник.Сумма - Источник.СуммаНДС - Источник.СуммаНП;

	Возврат(0);

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

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

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

	Возврат Источник.ЮрФизЛицо.Телефоны;

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат ОблагаетсяНДС(Источник);

	Возврат(0);

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

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

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

	ТипЦены = глПользователь.ОсновнойТипЦенПродажи;
	ЦенаЦены = 0;
	глВернутьЦену(Источник, ТипЦены, ФормДатаКон, ЦенаЦены);
	Возврат ЦенаЦены;

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПокупки.ЦенаВклНДС;

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПокупки.ЦенаВклНП;

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПродажи.ЦенаВклНДС;

	Возврат(0);

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

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

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

	Возврат глПользователь.ОсновнойТипЦенПродажи.ЦенаВклНП;

	Возврат(0);

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

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

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

	Возврат Источник.ЮрФизЛицо.ЮрАдрес;

	Возврат(0);

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

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

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

	Если Источник.ДокОснование.Выбран() = 1 Тогда
		Если (Источник.ДокОснование.Вид() = "ВводОстатковПоставщика") или (Источник.ДокОснование.Вид() = "ПоступлениеТМЦИмпорт") Тогда
			Возврат глРубли;
		КонецЕсли;
	КонецЕсли;
	
	Возврат Источник.Валюта;

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат Источник.Количество*Источник.Коэффициент;

	Возврат(0);

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

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

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

	Возврат Источник.Количество*Источник.Коэффициент;

	Возврат(0);

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

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

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

	Возврат Источник.Коэффициент*Источник.Количество;

	Возврат(0);

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

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

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

	Возврат Источник.Коэффициент*Источник.Количество;

	Возврат(0);

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

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

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

	Возврат Источник.Коэффициент*Источник.Количество;

	Возврат(0);

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

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

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

	Возврат Источник.Количество*Источник.Коэффициент;

	Возврат(0);

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

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

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

	Возврат Источник.Количество*Источник.Коэффициент;

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат глПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник) + " (расчеты с таможней)";

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ПредставлениеДокумента(Источник);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "Р", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "О", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "К", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "П", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "З", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "П", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "О", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "В", 8, "Справа");

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "", 8);

	Возврат(0);

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

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

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

	Возврат ДобавитьКПрефиксу(Источник.НомерДок, "С", 8, "Справа");

	Возврат(0);

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

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

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

	Родитель = Источник.Родитель;
	Если ПустоеЗначение(Родитель) = 1 Тогда Возврат(0) КонецЕсли;
	Пока Родитель.Уровень() > 1 Цикл
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат(Родитель);

	Возврат(0);

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

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

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

	Родитель = Источник.Родитель;
	Если ПустоеЗначение(Родитель) = 1 Тогда Возврат(0) КонецЕсли;
	Пока Родитель.Уровень() > 2 Цикл
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат(Родитель);

	Возврат(0);

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

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

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

	Родитель = Источник.Родитель;
	Если ПустоеЗначение(Родитель) = 1 Тогда Возврат(0) КонецЕсли;
	Пока Родитель.Уровень() > 2 Цикл
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат(Родитель);

	Возврат(0);

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

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

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

	Родитель = Источник.Родитель;
	Если ПустоеЗначение(Родитель) = 1 Тогда Возврат(0) КонецЕсли;
	Пока Родитель.Уровень() > 1 Цикл
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат(Родитель);

	Возврат(0);

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

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

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

	Родитель = Источник.Родитель;
	Если ПустоеЗначение(Родитель) = 1 Тогда Возврат(0) КонецЕсли;
	Пока Родитель.Уровень() > 2 Цикл
		Родитель = Родитель.Родитель;
	КонецЦикла;
	Возврат(Родитель);

	Возврат(0);

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

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

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

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

	Возврат(0);

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

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

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

	Возврат ПустоеЗначение(Источник.СтранаПроисхождения);

	Возврат(0);

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

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

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

	Возврат Источник.Сумма - Источник.СуммаНП;

	Возврат(0);

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

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

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

	Возврат Источник.Сумма - Источник.СуммаНП;

	Возврат(0);

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

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

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

	Возврат Источник.ЮрФизЛицо.ИНН;

	Возврат(0);

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

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


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

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

		Возврат(1);

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

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "PBU_000017" Тогда
			Возврат Условие_PBU_000017(Источник, СписокПараметровПравила);	//	Есть иные или не принимаемые расходы
		ИначеЕсли Ид = "PBU_000021" Тогда
			Возврат Условие_PBU_000021(Источник, СписокПараметровПравила);	//	Есть иные расходы
		ИначеЕсли Ид = "PBU_000019" Тогда
			Возврат Условие_PBU_000019(Источник, СписокПараметровПравила);	//	Есть прочие расходы
		ИначеЕсли Ид = "PBU_000004" Тогда
			Возврат Условие_PBU_000004(Источник, СписокПараметровПравила);	//	Есть табличная часть
		ИначеЕсли Ид = "PBU_000003" Тогда
			Возврат Условие_PBU_000003(Источник, СписокПараметровПравила);	//	(ЕстьСчетФактура = 0) и (Ввод остатков = 0)
		ИначеЕсли Ид = "PBU_000024" Тогда
			Возврат Условие_PBU_000024(Источник, СписокПараметровПравила);	//	Изм. вид деятельности
		ИначеЕсли Ид = "PBU_000018" Тогда
			Возврат Условие_PBU_000018(Источник, СписокПараметровПравила);	//	Иной или не принимаемый расход
		ИначеЕсли Ид = "PBU_000022" Тогда
			Возврат Условие_PBU_000022(Источник, СписокПараметровПравила);	//	Иной расход
		ИначеЕсли Ид = "PBU_000009" Тогда
			Возврат Условие_PBU_000009(Источник, СписокПараметровПравила);	//	Комплектация
		ИначеЕсли Ид = "PBU_000016" Тогда
			Возврат Условие_PBU_000016(Источник, СписокПараметровПравила);	//	Ввод остатков = 0
		ИначеЕсли Ид = "PBU_000023" Тогда
			Возврат Условие_PBU_000023(Источник, СписокПараметровПравила);	//	Не принимаемые расход
		ИначеЕсли Ид = "ID1С_0001006" Тогда
			Возврат Условие_ID1С_0001006(Источник, СписокПараметровПравила);	//	Свой р/с
		ИначеЕсли Ид = "PBU_000008" Тогда
			Возврат Условие_PBU_000008(Источник, СписокПараметровПравила);	//	Отбор документов
		ИначеЕсли Ид = "PBU_000020" Тогда
			Возврат Условие_PBU_000020(Источник, СписокПараметровПравила);	//	Прочий расход
		ИначеЕсли Ид = "ID1С_0001007" Тогда
			Возврат Условие_ID1С_0001007(Источник, СписокПараметровПравила);	//	Р/с контрагента
		ИначеЕсли Ид = "PBU_000010" Тогда
			Возврат Условие_PBU_000010(Источник, СписокПараметровПравила);	//	Разукомплектация
		ИначеЕсли Ид = "ID1С_0001010" Тогда
			Возврат Условие_ID1С_0001010(Источник, СписокПараметровПравила);	//	Уровень группы > 1
		ИначеЕсли Ид = "ID1С_0001008" Тогда
			Возврат Условие_ID1С_0001008(Источник, СписокПараметровПравила);	//	Уровень группы > 2
		ИначеЕсли Ид = "ID1С_0001009" Тогда
			Возврат Условие_ID1С_0001009(Источник, СписокПараметровПравила);	//	Уровень группы > 2
		ИначеЕсли Ид = "ID1С_0001011" Тогда
			Возврат Условие_ID1С_0001011(Источник, СписокПараметровПравила);	//	Уровень группы > 2
		КонецЕсли;

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

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "ID_PBU_000243" Тогда
			Возврат ПравилоВыборкиОбъектов_ID_PBU_000243(Ид);	//	Разукомплектация
		ИначеЕсли Ид = "ID_PBU_000047" Тогда
			Возврат ПравилоВыборкиОбъектов_ID_PBU_000047(Ид);	//	Перед началом выгрузки
		ИначеЕсли Ид = "ID_PBU_002649" Тогда
			Возврат ПравилоВыборкиОбъектов_ID_PBU_002649(Ид);	//	Списание
		КонецЕсли;

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

		Если Ид = "" Тогда
			Возврат(1);
		ИначеЕсли Ид = "PBU_002662" Тогда
			Возврат ПравилоРеквизита_PBU_002662(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002795" Тогда
			Возврат ПравилоРеквизита_PBU_002795(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002516" Тогда
			Возврат ПравилоРеквизита_PBU_002516(Источник, Приемник, СписокПараметровПравила);	//	Суммовые разницы
		ИначеЕсли Ид = "PBU_002891" Тогда
			Возврат ПравилоРеквизита_PBU_002891(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002654" Тогда
			Возврат ПравилоРеквизита_PBU_002654(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002999" Тогда
			Возврат ПравилоРеквизита_PBU_002999(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002655" Тогда
			Возврат ПравилоРеквизита_PBU_002655(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002801" Тогда
			Возврат ПравилоРеквизита_PBU_002801(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002802" Тогда
			Возврат ПравилоРеквизита_PBU_002802(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002656" Тогда
			Возврат ПравилоРеквизита_PBU_002656(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002657" Тогда
			Возврат ПравилоРеквизита_PBU_002657(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002658" Тогда
			Возврат ПравилоРеквизита_PBU_002658(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002659" Тогда
			Возврат ПравилоРеквизита_PBU_002659(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002660" Тогда
			Возврат ПравилоРеквизита_PBU_002660(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002838" Тогда
			Возврат ПравилоРеквизита_PBU_002838(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002892" Тогда
			Возврат ПравилоРеквизита_PBU_002892(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002859" Тогда
			Возврат ПравилоРеквизита_PBU_002859(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002867" Тогда
			Возврат ПравилоРеквизита_PBU_002867(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002876" Тогда
			Возврат ПравилоРеквизита_PBU_002876(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_001126" Тогда
			Возврат ПравилоРеквизита_PBU_001126(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002922" Тогда
			Возврат ПравилоРеквизита_PBU_002922(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002936" Тогда
			Возврат ПравилоРеквизита_PBU_002936(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_002943" Тогда
			Возврат ПравилоРеквизита_PBU_002943(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_003143" Тогда
			Возврат ПравилоРеквизита_PBU_003143(Источник, Приемник, СписокПараметровПравила);	//	-->
		ИначеЕсли Ид = "PBU_000593" Тогда
			Возврат ПравилоРеквизита_PBU_000593(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_002645" Тогда
			Возврат ПравилоРеквизита_PBU_002645(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_000980" Тогда
			Возврат ПравилоРеквизита_PBU_000980(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_002908" Тогда
			Возврат ПравилоРеквизита_PBU_002908(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_003075" Тогда
			Возврат ПравилоРеквизита_PBU_003075(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_003015" Тогда
			Возврат ПравилоРеквизита_PBU_003015(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_003045" Тогда
			Возврат ПравилоРеквизита_PBU_003045(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_003111" Тогда
			Возврат ПравилоРеквизита_PBU_003111(Источник, Приемник, СписокПараметровПравила);	//	-->  АвтоКнигаПокупок
		ИначеЕсли Ид = "PBU_000058" Тогда
			Возврат ПравилоРеквизита_PBU_000058(Источник, Приемник, СписокПараметровПравила);	//	-->  ВалютаПокупки
		ИначеЕсли Ид = "PBU_000059" Тогда
			Возврат ПравилоРеквизита_PBU_000059(Источник, Приемник, СписокПараметровПравила);	//	-->  ВалютаПродажи
		ИначеЕсли Ид = "PBU_000314" Тогда
			Возврат ПравилоРеквизита_PBU_000314(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_000770" Тогда
			Возврат ПравилоРеквизита_PBU_000770(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_000430" Тогда
			Возврат ПравилоРеквизита_PBU_000430(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_000594" Тогда
			Возврат ПравилоРеквизита_PBU_000594(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_002592" Тогда
			Возврат ПравилоРеквизита_PBU_002592(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_002512" Тогда
			Возврат ПравилоРеквизита_PBU_002512(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_002646" Тогда
			Возврат ПравилоРеквизита_PBU_002646(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_003034" Тогда
			Возврат ПравилоРеквизита_PBU_003034(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_003100" Тогда
			Возврат ПравилоРеквизита_PBU_003100(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_003133" Тогда
			Возврат ПравилоРеквизита_PBU_003133(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_002973" Тогда
			Возврат ПравилоРеквизита_PBU_002973(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельности
		ИначеЕсли Ид = "PBU_000431" Тогда
			Возврат ПравилоРеквизита_PBU_000431(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидДеятельностиКон
		ИначеЕсли Ид = "PBU_000278" Тогда
			Возврат ПравилоРеквизита_PBU_000278(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидКорректировки
		ИначеЕсли Ид = "PBU_000982" Тогда
			Возврат ПравилоРеквизита_PBU_000982(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидМатериальногоРесурса
		ИначеЕсли Ид = "PBU_000315" Тогда
			Возврат ПравилоРеквизита_PBU_000315(Источник, Приемник, СписокПараметровПравила);	//	-->  ВидМатериальногоРесурса
		ИначеЕсли Ид = "PBU_000983" Тогда
			Возврат ПравилоРеквизита_PBU_000983(Источник, Приемник, СписокПараметровПравила);	//	-->  ГТД
		ИначеЕсли Ид = "PBU_000160" Тогда
			Возврат ПравилоРеквизита_PBU_000160(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_000181" Тогда
			Возврат ПравилоРеквизита_PBU_000181(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_000597" Тогда
			Возврат ПравилоРеквизита_PBU_000597(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_002649" Тогда
			Возврат ПравилоРеквизита_PBU_002649(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_000984" Тогда
			Возврат ПравилоРеквизита_PBU_000984(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_001124" Тогда
			Возврат ПравилоРеквизита_PBU_001124(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_002910" Тогда
			Возврат ПравилоРеквизита_PBU_002910(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_003076" Тогда
			Возврат ПравилоРеквизита_PBU_003076(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_003016" Тогда
			Возврат ПравилоРеквизита_PBU_003016(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_003046" Тогда
			Возврат ПравилоРеквизита_PBU_003046(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_003112" Тогда
			Возврат ПравилоРеквизита_PBU_003112(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаНомерСчетаФактуры
		ИначеЕсли Ид = "PBU_000161" Тогда
			Возврат ПравилоРеквизита_PBU_000161(Источник, Приемник, СписокПараметровПравила);	//	-->  ДатаОприходования
		ИначеЕсли Ид = "PBU_001034" Тогда
			Возврат ПравилоРеквизита_PBU_001034(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументПодтверждающийФактОплаты
		ИначеЕсли Ид = "PBU_001063" Тогда
			Возврат ПравилоРеквизита_PBU_001063(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументПодтверждающийФактОплаты
		ИначеЕсли Ид = "PBU_003141" Тогда
			Возврат ПравилоРеквизита_PBU_003141(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументПодтверждающийФактОплаты
		ИначеЕсли Ид = "PBU_003102" Тогда
			Возврат ПравилоРеквизита_PBU_003102(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументПоступления
		ИначеЕсли Ид = "PBU_003036" Тогда
			Возврат ПравилоРеквизита_PBU_003036(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументПоступления
		ИначеЕсли Ид = "PBU_000038" Тогда
			Возврат ПравилоРеквизита_PBU_000038(Источник, Приемник, СписокПараметровПравила);	//	-->  ДокументУдЛичность
		ИначеЕсли Ид = "PBU_000598" Тогда
			Возврат ПравилоРеквизита_PBU_000598(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_002650" Тогда
			Возврат ПравилоРеквизита_PBU_002650(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_000986" Тогда
			Возврат ПравилоРеквизита_PBU_000986(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_002911" Тогда
			Возврат ПравилоРеквизита_PBU_002911(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_003078" Тогда
			Возврат ПравилоРеквизита_PBU_003078(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_003018" Тогда
			Возврат ПравилоРеквизита_PBU_003018(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_003048" Тогда
			Возврат ПравилоРеквизита_PBU_003048(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_003114" Тогда
			Возврат ПравилоРеквизита_PBU_003114(Источник, Приемник, СписокПараметровПравила);	//	-->  ЕстьСчетФактура
		ИначеЕсли Ид = "PBU_002489" Тогда
			Возврат ПравилоРеквизита_PBU_002489(Источник, Приемник, СписокПараметровПравила);	//	-->  Код
		ИначеЕсли Ид = "PBU_000236" Тогда
			Возврат ПравилоРеквизита_PBU_000236(Источник, Приемник, СписокПараметровПравила);	//	-->  КоличествоПолучено
		ИначеЕсли Ид = "PBU_003074" Тогда
			Возврат ПравилоРеквизита_PBU_003074(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_002786" Тогда
			Возврат ПравилоРеквизита_PBU_002786(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_003008" Тогда
			Возврат ПравилоРеквизита_PBU_003008(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_003014" Тогда
			Возврат ПравилоРеквизита_PBU_003014(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_003044" Тогда
			Возврат ПравилоРеквизита_PBU_003044(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_003099" Тогда
			Возврат ПравилоРеквизита_PBU_003099(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_003110" Тогда
			Возврат ПравилоРеквизита_PBU_003110(Источник, Приемник, СписокПараметровПравила);	//	-->  Комментарий
		ИначеЕсли Ид = "PBU_000842" Тогда
			Возврат ПравилоРеквизита_PBU_000842(Источник, Приемник, СписокПараметровПравила);	//	-->  КоррСчет
		ИначеЕсли Ид = "PBU_000466" Тогда
			Возврат ПравилоРеквизита_PBU_000466(Источник, Приемник, СписокПараметровПравила);	//	-->  КоррСчет
		ИначеЕсли Ид = "PBU_000467" Тогда
			Возврат ПравилоРеквизита_PBU_000467(Источник, Приемник, СписокПараметровПравила);	//	-->  НДС
		ИначеЕсли Ид = "PBU_000493" Тогда
			Возврат ПравилоРеквизита_PBU_000493(Источник, Приемник, СписокПараметровПравила);	//	-->  НДС
		ИначеЕсли Ид = "PBU_002782" Тогда
			Возврат ПравилоРеквизита_PBU_002782(Источник, Приемник, СписокПараметровПравила);	//	-->  НомерДок
		ИначеЕсли Ид = "PBU_002726" Тогда
			Возврат ПравилоРеквизита_PBU_002726(Источник, Приемник, СписокПараметровПравила);	//	-->  НомерДок
		ИначеЕсли Ид = "PBU_000468" Тогда
			Возврат ПравилоРеквизита_PBU_000468(Источник, Приемник, СписокПараметровПравила);	//	-->  НП
		ИначеЕсли Ид = "PBU_001137" Тогда
			Возврат ПравилоРеквизита_PBU_001137(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяЕНВД
		ИначеЕсли Ид = "PBU_000316" Тогда
			Возврат ПравилоРеквизита_PBU_000316(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_000434" Тогда
			Возврат ПравилоРеквизита_PBU_000434(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_000599" Тогда
			Возврат ПравилоРеквизита_PBU_000599(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002597" Тогда
			Возврат ПравилоРеквизита_PBU_002597(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002515" Тогда
			Возврат ПравилоРеквизита_PBU_002515(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002651" Тогда
			Возврат ПравилоРеквизита_PBU_002651(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002853" Тогда
			Возврат ПравилоРеквизита_PBU_002853(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002874" Тогда
			Возврат ПравилоРеквизита_PBU_002874(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_000988" Тогда
			Возврат ПравилоРеквизита_PBU_000988(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_002912" Тогда
			Возврат ПравилоРеквизита_PBU_002912(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_000246" Тогда
			Возврат ПравилоРеквизита_PBU_000246(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_003020" Тогда
			Возврат ПравилоРеквизита_PBU_003020(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_003050" Тогда
			Возврат ПравилоРеквизита_PBU_003050(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_003080" Тогда
			Возврат ПравилоРеквизита_PBU_003080(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_003116" Тогда
			Возврат ПравилоРеквизита_PBU_003116(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДС
		ИначеЕсли Ид = "PBU_000435" Тогда
			Возврат ПравилоРеквизита_PBU_000435(Источник, Приемник, СписокПараметровПравила);	//	-->  ОблагаетсяНДСКон
		ИначеЕсли Ид = "PBU_000843" Тогда
			Возврат ПравилоРеквизита_PBU_000843(Источник, Приемник, СписокПараметровПравила);	//	-->  ПоДокументу
		ИначеЕсли Ид = "PBU_000047" Тогда
			Возврат ПравилоРеквизита_PBU_000047(Источник, Приемник, СписокПараметровПравила);	//	-->  ПолнНаименование
		ИначеЕсли Ид = "PBU_000048" Тогда
			Возврат ПравилоРеквизита_PBU_000048(Источник, Приемник, СписокПараметровПравила);	//	-->  ПочтовыйАдрес
		ИначеЕсли Ид = "PBU_000065" Тогда
			Возврат ПравилоРеквизита_PBU_000065(Источник, Приемник, СписокПараметровПравила);	//	-->  Стоимость
		ИначеЕсли Ид = "PBU_000285" Тогда
			Возврат ПравилоРеквизита_PBU_000285(Источник, Приемник, СписокПараметровПравила);	//	-->  Сумма
		ИначеЕсли Ид = "PBU_000162" Тогда
			Возврат ПравилоРеквизита_PBU_000162(Источник, Приемник, СписокПараметровПравила);	//	-->  СуммаБезНДС
		ИначеЕсли Ид = "PBU_000183" Тогда
			Возврат ПравилоРеквизита_PBU_000183(Источник, Приемник, СписокПараметровПравила);	//	-->  СуммаБезНДС
		ИначеЕсли Ид = "PBU_000049" Тогда
			Возврат ПравилоРеквизита_PBU_000049(Источник, Приемник, СписокПараметровПравила);	//	-->  Телефоны
		ИначеЕсли Ид = "PBU_001032" Тогда
			Возврат ПравилоРеквизита_PBU_001032(Источник, Приемник, СписокПараметровПравила);	//	-->  ТипСчета
		ИначеЕсли Ид = "PBU_000397" Тогда
			Возврат ПравилоРеквизита_PBU_000397(Источник, Приемник, СписокПараметровПравила);	//	-->  УчитыватьНДС
		ИначеЕсли Ид = "PBU_000068" Тогда
			Возврат ПравилоРеквизита_PBU_000068(Источник, Приемник, СписокПараметровПравила);	//	-->  Цена
		ИначеЕсли Ид = "PBU_000069" Тогда
			Возврат ПравилоРеквизита_PBU_000069(Источник, Приемник, СписокПараметровПравила);	//	-->  ЦенаПокупкиВклНДС
		ИначеЕсли Ид = "PBU_000070" Тогда
			Возврат ПравилоРеквизита_PBU_000070(Источник, Приемник, СписокПараметровПравила);	//	-->  ЦенаПокупкиВклНП
		ИначеЕсли Ид = "PBU_000071" Тогда
			Возврат ПравилоРеквизита_PBU_000071(Источник, Приемник, СписокПараметровПравила);	//	-->  ЦенаПродажиВклНДС
		ИначеЕсли Ид = "PBU_000072" Тогда
			Возврат ПравилоРеквизита_PBU_000072(Источник, Приемник, СписокПараметровПравила);	//	-->  ЦенаПродажиВклНП
		ИначеЕсли Ид = "PBU_000050" Тогда
			Возврат ПравилоРеквизита_PBU_000050(Источник, Приемник, СписокПараметровПравила);	//	-->  ЮридическийАдрес
		ИначеЕсли Ид = "PBU_001111" Тогда
			Возврат ПравилоРеквизита_PBU_001111(Источник, Приемник, СписокПараметровПравила);	//	Валюта  -->  Валюта
		ИначеЕсли Ид = "PBU_000168" Тогда
			Возврат ПравилоРеквизита_PBU_000168(Источник, Приемник, СписокПараметровПравила);	//	ДокОснование  -->  ДокОснование
		ИначеЕсли Ид = "PBU_000147" Тогда
			Возврат ПравилоРеквизита_PBU_000147(Источник, Приемник, СписокПараметровПравила);	//	ДокОснование  -->  ДокОснование
		ИначеЕсли Ид = "PBU_002542" Тогда
			Возврат ПравилоРеквизита_PBU_002542(Источник, Приемник, СписокПараметровПравила);	//	ДокОснование  -->  ДокументОтгрузки
		ИначеЕсли Ид = "PBU_000195" Тогда
			Возврат ПравилоРеквизита_PBU_000195(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "PBU_000293" Тогда
			Возврат ПравилоРеквизита_PBU_000293(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "PBU_000955" Тогда
			Возврат ПравилоРеквизита_PBU_000955(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "ID1С_0019223" Тогда
			Возврат ПравилоРеквизита_ID1С_0019223(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "ID1С_0019232" Тогда
			Возврат ПравилоРеквизита_ID1С_0019232(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "ID1С_0019252" Тогда
			Возврат ПравилоРеквизита_ID1С_0019252(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "ID1С_0019268" Тогда
			Возврат ПравилоРеквизита_ID1С_0019268(Источник, Приемник, СписокПараметровПравила);	//	Количество  -->  Количество
		ИначеЕсли Ид = "ID1С_0019224" Тогда
			Возврат ПравилоРеквизита_ID1С_0019224(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002817" Тогда
			Возврат ПравилоРеквизита_PBU_002817(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000262" Тогда
			Возврат ПравилоРеквизита_PBU_000262(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000892" Тогда
			Возврат ПравилоРеквизита_PBU_000892(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002496" Тогда
			Возврат ПравилоРеквизита_PBU_002496(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002524" Тогда
			Возврат ПравилоРеквизита_PBU_002524(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000445" Тогда
			Возврат ПравилоРеквизита_PBU_000445(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000824" Тогда
			Возврат ПравилоРеквизита_PBU_000824(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_001000" Тогда
			Возврат ПравилоРеквизита_PBU_001000(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_001048" Тогда
			Возврат ПравилоРеквизита_PBU_001048(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000568" Тогда
			Возврат ПравилоРеквизита_PBU_000568(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002561" Тогда
			Возврат ПравилоРеквизита_PBU_002561(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002843" Тогда
			Возврат ПравилоРеквизита_PBU_002843(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002871" Тогда
			Возврат ПравилоРеквизита_PBU_002871(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002618" Тогда
			Возврат ПравилоРеквизита_PBU_002618(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000956" Тогда
			Возврат ПравилоРеквизита_PBU_000956(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000109" Тогда
			Возврат ПравилоРеквизита_PBU_000109(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000196" Тогда
			Возврат ПравилоРеквизита_PBU_000196(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000880" Тогда
			Возврат ПравилоРеквизита_PBU_000880(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000479" Тогда
			Возврат ПравилоРеквизита_PBU_000479(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000370" Тогда
			Возврат ПравилоРеквизита_PBU_000370(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000335" Тогда
			Возврат ПравилоРеквизита_PBU_000335(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000713" Тогда
			Возврат ПравилоРеквизита_PBU_000713(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000749" Тогда
			Возврат ПравилоРеквизита_PBU_000749(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000785" Тогда
			Возврат ПравилоРеквизита_PBU_000785(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002713" Тогда
			Возврат ПравилоРеквизита_PBU_002713(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000149" Тогда
			Возврат ПравилоРеквизита_PBU_000149(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_001119" Тогда
			Возврат ПравилоРеквизита_PBU_001119(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000170" Тогда
			Возврат ПравилоРеквизита_PBU_000170(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_001077" Тогда
			Возврат ПравилоРеквизита_PBU_001077(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000406" Тогда
			Возврат ПравилоРеквизита_PBU_000406(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000294" Тогда
			Возврат ПравилоРеквизита_PBU_000294(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_000230" Тогда
			Возврат ПравилоРеквизита_PBU_000230(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_002900" Тогда
			Возврат ПравилоРеквизита_PBU_002900(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "ID1С_0019233" Тогда
			Возврат ПравилоРеквизита_ID1С_0019233(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "ID1С_0019249" Тогда
			Возврат ПравилоРеквизита_ID1С_0019249(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "ID1С_0019264" Тогда
			Возврат ПравилоРеквизита_ID1С_0019264(Источник, Приемник, СписокПараметровПравила);	//	Комментарий  -->  Комментарий
		ИначеЕсли Ид = "PBU_001051" Тогда
			Возврат ПравилоРеквизита_PBU_001051(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000718" Тогда
			Возврат ПравилоРеквизита_PBU_000718(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_001122" Тогда
			Возврат ПравилоРеквизита_PBU_001122(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_001003" Тогда
			Возврат ПравилоРеквизита_PBU_001003(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000115" Тогда
			Возврат ПравилоРеквизита_PBU_000115(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000151" Тогда
			Возврат ПравилоРеквизита_PBU_000151(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000172" Тогда
			Возврат ПравилоРеквизита_PBU_000172(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000201" Тогда
			Возврат ПравилоРеквизита_PBU_000201(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000298" Тогда
			Возврат ПравилоРеквизита_PBU_000298(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000375" Тогда
			Возврат ПравилоРеквизита_PBU_000375(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000448" Тогда
			Возврат ПравилоРеквизита_PBU_000448(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000482" Тогда
			Возврат ПравилоРеквизита_PBU_000482(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000827" Тогда
			Возврат ПравилоРеквизита_PBU_000827(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000881" Тогда
			Возврат ПравилоРеквизита_PBU_000881(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000340" Тогда
			Возврат ПравилоРеквизита_PBU_000340(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000752" Тогда
			Возврат ПравилоРеквизита_PBU_000752(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000790" Тогда
			Возврат ПравилоРеквизита_PBU_000790(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000410" Тогда
			Возврат ПравилоРеквизита_PBU_000410(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_002500" Тогда
			Возврат ПравилоРеквизита_PBU_002500(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_002528" Тогда
			Возврат ПравилоРеквизита_PBU_002528(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "ID1С_0019226" Тогда
			Возврат ПравилоРеквизита_ID1С_0019226(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "ID1С_0019235" Тогда
			Возврат ПравилоРеквизита_ID1С_0019235(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "ID1С_0019245" Тогда
			Возврат ПравилоРеквизита_ID1С_0019245(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "ID1С_0019260" Тогда
			Возврат ПравилоРеквизита_ID1С_0019260(Источник, Приемник, СписокПараметровПравила);	//	НомерДок  -->  НомерДок
		ИначеЕсли Ид = "PBU_000044" Тогда
			Возврат ПравилоРеквизита_PBU_000044(Источник, Приемник, СписокПараметровПравила);	//	Родитель  -->  Родитель
		ИначеЕсли Ид = "PBU_000036" Тогда
			Возврат ПравилоРеквизита_PBU_000036(Источник, Приемник, СписокПараметровПравила);	//	Родитель  -->  Родитель
		ИначеЕсли Ид = "PBU_000054" Тогда
			Возврат ПравилоРеквизита_PBU_000054(Источник, Приемник, СписокПараметровПравила);	//	Родитель  -->  Родитель
		ИначеЕсли Ид = "PBU_000517" Тогда
			Возврат ПравилоРеквизита_PBU_000517(Источник, Приемник, СписокПараметровПравила);	//	Родитель  -->  Родитель
		ИначеЕсли Ид = "PBU_002940" Тогда
			Возврат ПравилоРеквизита_PBU_002940(Источник, Приемник, СписокПараметровПравила);	//	Родитель  -->  Родитель
		ИначеЕсли Ид = "PBU_000883" Тогда
			Возврат ПравилоРеквизита_PBU_000883(Источник, Приемник, СписокПараметровПравила);	//	СторнируемыйДокумент  -->  СторнируемыйДокумент
		ИначеЕсли Ид = "PBU_000057" Тогда
			Возврат ПравилоРеквизита_PBU_000057(Источник, Приемник, СписокПараметровПравила);	//	СтранаПроисхождения  -->  СтранаПроисхождения
		ИначеЕсли Ид = "PBU_000155" Тогда
			Возврат ПравилоРеквизита_PBU_000155(Источник, Приемник, СписокПараметровПравила);	//	Сумма  -->  Сумма
		ИначеЕсли Ид = "PBU_000176" Тогда
			Возврат ПравилоРеквизита_PBU_000176(Источник, Приемник, СписокПараметровПравила);	//	Сумма  -->  Сумма
		ИначеЕсли Ид = "PBU_000039" Тогда
			Возврат ПравилоРеквизита_PBU_000039(Источник, Приемник, СписокПараметровПравила);	//	ЮрФизЛицо  -->  ИНН
		КонецЕсли;

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

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

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

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

	КонецЕсли;

	Возврат(0);

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

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

