MediaWiki:Gadget-twinkleblock.js

// <nowiki>  


(function($) {

var api = new mw.Api(), relevantUserName, blockedUserName;
var menuFormattedNamespaces = $.extend({}, mw.config.get('wgFormattedNamespaces'));
menuFormattedNamespaces[0] = '(Madde)';

/*
 ****************************************
 *** twinkleblock.js: Engelleme modülü
 ****************************************
 * Çağırma modu:           Sekme ("Engelle")
 * Etkin olduğu yerler:    Kullanıcılarla ilgili her türlü sayfa (kullanıcı sayfası, katkılar vb.)
 */

Twinkle.block = function twinkleblock() {
	relevantUserName = mw.config.get('wgRelevantUserName');
	// should show on Contributions or Block pages, anywhere there's a relevant user
	// Ignore ranges wider than the CIDR limit
	if (Morebits.userIsSysop && relevantUserName && (!Morebits.ip.isRange(relevantUserName) || Morebits.ip.validCIDR(relevantUserName))) {
		Twinkle.addPortletLink(Twinkle.block.callback, 'Engelle', 'tw-block', 'İlgili kullanıcı engelle');
	}
};

Twinkle.block.callback = function twinkleblockCallback() {
	if (relevantUserName === mw.config.get('wgUserName') &&
			!confirm('Kendinizi engellemek üzeresiniz! Bunu yapmak istediğinizden emin misiniz?')) {
		return;
	}

	Twinkle.block.currentBlockInfo = undefined;
	Twinkle.block.field_block_options = {};
	Twinkle.block.field_template_options = {};

	var Window = new Morebits.simpleWindow(650, 530);
	// need to be verbose about who we're blocking
	Window.setTitle( relevantUserName + ' kullanıcısını engelleyin veya engel şablonu yerleştirin');
	Window.setScriptName('Twinkle');
	Window.addFooterLink('Engel şablonları', 'Şablon:Ku-engel/belge/Engel şablonları/Tümü');
	Window.addFooterLink('Engelleme politikası', 'VP:EP');
	Window.addFooterLink('Engel tercihleri', 'Vikipedi:Twinkle/Tercihler#block');
	Window.addFooterLink('Twinkle yardım', 'VT:TW');
	//Window.addFooterLink('Give feedback', 'WT:TW');
	
	// Always added, hidden later if actual user not blocked
	Window.addFooterLink('Kullanıcının engelini kaldır', 'Special:Unblock/' + relevantUserName, true);
	
	var form = new Morebits.quickForm(Twinkle.block.callback.evaluate);
	var actionfield = form.append({
		type: 'field',
		label: 'Eylem türü'
	});
	actionfield.append({
		type: 'checkbox',
		name: 'actiontype',
		event: Twinkle.block.callback.change_action,
		list: [
			{
				label: 'Kullanıcıyı engelle',
				value: 'block',
				tooltip: 'Verilen seçeneklerle ilgili kullanıcıyı engelleyin. Kısmi seçeneği işaretli değilse, engel, site çapında etkili olacaktır.',
				checked: true
			},
			{
				label: 'Kısmi',
				value: 'partial',
				tooltip: 'Kısmi engeli ve kısmi engel şablonlarını etkinleştirin.',
				checked: Twinkle.getPref('defaultToPartialBlocks')  // Overridden if already blocked
			},
			{
				label: 'Kullanıcı mesaj sayfasına engel şablonu ekleyin',
				value: 'template',
				tooltip: 'Engelleyen hizmetli bir engel şablonu eklemeyi unuttuysa veya kullanıcıyı şablon eklemeden engellediyseniz, uygun şablonu eklemek için bunu kullanabilirsiniz. Kısmi engel şablonları için kısmi engel seçeneğini işaretleyin.',
				// Disallow when viewing the block dialog on an IP range
				checked: !Morebits.ip.isRange(relevantUserName),
				disabled: Morebits.ip.isRange(relevantUserName)
			}
		]
	});
	
	/*
	  Add option for IPv6 ranges smaller than /64 to upgrade to the 64
	  CIDR ([[WP:/64]]).  This is one of the few places where we want
	  wgRelevantUserName since this depends entirely on the original user.
	  In theory, we shouldn't use Morebits.ip.get64 here since since we want
	  to exclude functionally-equivalent /64s.  That'd be:
	  // if (mw.util.isIPv6Address(mw.config.get('wgRelevantUserName'), true) &&
	  // (mw.util.isIPv6Address(mw.config.get('wgRelevantUserName')) || parseInt(mw.config.get('wgRelevantUserName').replace(/^(.+?)\/?(\d{1,3})?$/, '$2'), 10) > 64)) {
	  In practice, though, since functionally-equivalent ranges are
	  (mis)treated as separate by MediaWiki's logging ([[phab:T146628]]),
	  using Morebits.ip.get64 provides a modicum of relief in thise case.
	*/
	var sixtyFour = Morebits.ip.get64(mw.config.get('wgRelevantUserName'));
	if (sixtyFour && sixtyFour !== mw.config.get('wgRelevantUserName')) {
		var block64field = form.append({
			type: 'field',
			label: '/64 aralık engeline dönüştür',
			name: 'field_64'
		});
		block64field.append({
			type: 'div',
			style: 'margin-bottom: 0.5em',
			label: ['Sadece ', $.parseHTML('<a target="_blank" href="' + mw.util.getUrl('en:WP:/64') + '">/64 aralığını</a>')[0], ' engellemek daha iyi değilse bile genellikle yeterlidir (',
				$.parseHTML('<a target="_blank" href="' + mw.util.getUrl('Special:Contributions/' + sixtyFour) + '">' + sixtyFour + '</a>)')[0], ').']
		});
		block64field.append({
			type: 'checkbox',
			name: 'block64',
			event: Twinkle.block.callback.change_block64,
			list: [{
				checked: Twinkle.getPref('defaultToBlock64'),
				label: 'IP adresi yerine /64 aralığını engelle',
				value: 'block64',
				tooltip: Morebits.ip.isRange(mw.config.get('wgRelevantUserName')) ? 'Şablon bırakmaktan sakınılacak.' : 'Verilen herhangi bir şablon orijinal IP adesine gidecektir: ' + mw.config.get('wgRelevantUserName')
			}]
		});
	}

	form.append({ type: 'field', label: 'Ön ayar', name: 'field_preset' });
	form.append({ type: 'field', label: 'Şablon seçenekleri', name: 'field_template_options' });
	form.append({ type: 'field', label: 'Engel seçenekleri', name: 'field_block_options' });

	form.append({ type: 'submit' });

	var result = form.render();
	Window.setContent(result);
	Window.display();
	result.root = result;

	Twinkle.block.fetchUserInfo(function() {
		// Toggle initial partial state depending on prior block type,
		// will override the defaultToPartialBlocks pref
		if (blockedUserName === relevantUserName) {
			$(result).find('[name=actiontype][value=partial]').prop('checked', Twinkle.block.currentBlockInfo.partial === '');
		}
		
		// clean up preset data (defaults, etc.), done exactly once, must be before Twinkle.block.callback.change_action is called
		Twinkle.block.transformBlockPresets();

		// init the controls after user and block info have been fetched
		var evt = document.createEvent('Event');
		evt.initEvent('change', true, true);

		if (result.block64 && result.block64.checked) {
			// Calls the same change_action event once finished
			result.block64.dispatchEvent(evt);
		} else {
			result.actiontype[0].dispatchEvent(evt);
		}
	});
};

// Store fetched user data, only relevant if switching IPv6 to a /64
Twinkle.block.fetchedData = {};
// Processes the data from a a query response, separated from
// Twinkle.block.fetchUserInfo to allow reprocessing of already-fetched data
Twinkle.block.processUserInfo = function twinkleblockProcessUserInfo(data, fn) {
	var blockinfo = data.query.blocks[0],
		userinfo = data.query.users[0];
	// If an IP is blocked *and* rangeblocked, the above finds
	// whichever block is more recent, not necessarily correct.
	// Three seems... unlikely
	if (data.query.blocks.length > 1 && blockinfo.user !== relevantUserName) {
		blockinfo = data.query.blocks[1];
	}
	// Cache response, used when toggling /64 blocks
	Twinkle.block.fetchedData[userinfo.name] = data;

	Twinkle.block.isRegistered = !!userinfo.userid;
	if (Twinkle.block.isRegistered) {
		Twinkle.block.userIsBot = !!userinfo.groupmemberships && userinfo.groupmemberships.map(function(e) {
			return e.group;
		}).indexOf('bot') !== -1;
	} else {
		Twinkle.block.userIsBot = false;
	}

	if (blockinfo) {
		// handle frustrating system of inverted boolean values
		blockinfo.disabletalk = blockinfo.allowusertalk === undefined;
		blockinfo.hardblock = blockinfo.anononly === undefined;
	}
	// will undefine if no blocks present
	Twinkle.block.currentBlockInfo = blockinfo;
	blockedUserName = Twinkle.block.currentBlockInfo && Twinkle.block.currentBlockInfo.user;

	// Toggle unblock link if not the user in question; always first
	var unblockLink = document.querySelector('.morebits-dialog-footerlinks a');
	if (blockedUserName !== relevantUserName) {
		unblockLink.hidden = true, unblockLink.nextSibling.hidden = true; // link+trailing bullet
	} else {
		unblockLink.hidden = false, unblockLink.nextSibling.hidden = false; // link+trailing bullet
	}

	// Semi-busted on ranges, see [[phab:T270737]] and [[phab:T146628]].
	// Basically, logevents doesn't treat functionally-equivalent ranges
	// as equivalent, meaning any functionally-equivalent IP range is
	// misinterpreted by the log throughout.  Without logevents
	// redirecting (like Special:Block does) we would need a function to
	// parse ranges, which is a pain.  IPUtils has the code, but it'd be a
	// lot of cruft for one purpose.
	Twinkle.block.hasBlockLog = !!data.query.logevents.length;
	Twinkle.block.blockLog = Twinkle.block.hasBlockLog && data.query.logevents;
	// Used later to check if block status changed while filling out the form
	Twinkle.block.blockLogId = Twinkle.block.hasBlockLog ? data.query.logevents[0].logid : false;

	if (typeof fn === 'function') {
		return fn();
	}
};

Twinkle.block.fetchUserInfo = function twinkleblockFetchUserInfo(fn) {
	var query = {
		format: 'json',
		action: 'query',
		list: 'blocks|users|logevents',
		letype: 'block',
		lelimit: 1,
		letitle: 'User:' + relevantUserName,
		bkprop: 'expiry|reason|flags|restrictions|range|user',
		ususers: relevantUserName
	};

	// bkusers doesn't catch single IPs blocked as part of a range block
	if (mw.util.isIPAddress(relevantUserName, true)) {
		query.bkip = relevantUserName;
	} else {
		query.bkusers = relevantUserName;
		// groupmemberships only relevant for registered users
		query.usprop = 'groupmemberships';
	}

	api.get(query).then(function(data) {
		Twinkle.block.processUserInfo(data, fn);
	}, function(msg) {
		Morebits.status.init($('div[name="currentblock"] span').last()[0]);
		Morebits.status.warn('Error fetching user info', msg);
	});
};

Twinkle.block.callback.saveFieldset = function twinkleblockCallbacksaveFieldset(fieldset) {
	Twinkle.block[$(fieldset).prop('name')] = {};
	$(fieldset).serializeArray().forEach(function(el) {
		// namespaces and pages for partial blocks are overwritten
		// here, but we're handling them elsewhere so that's fine
		Twinkle.block[$(fieldset).prop('name')][el.name] = el.value;
	});
};

Twinkle.block.callback.change_block64 = function twinkleblockCallbackChangeBlock64(e) {
	var $form = $(e.target.form), $block64 = $form.find('[name=block64]');

	// Show/hide block64 button
	// Single IPv6, or IPv6 range smaller than a /64
	var priorName = relevantUserName;
	if ($block64.is(':checked')) {
		relevantUserName = Morebits.ip.get64(mw.config.get('wgRelevantUserName'));
	} else {
		relevantUserName = mw.config.get('wgRelevantUserName');
	}
	// No templates for ranges, but if the original user is a single IP, offer the option
	// (done separately in Twinkle.block.callback.issue_template)
	var originalIsRange = Morebits.ip.isRange(mw.config.get('wgRelevantUserName'));
	$form.find('[name=actiontype][value=template]').prop('disabled', originalIsRange).prop('checked', !originalIsRange);

	// Refetch/reprocess user info then regenerate the main content
	var regenerateForm = function() {
		// Tweak titlebar text.  In theory, we could save the dialog
		// at initialization and then use `.setTitle` or
		// `dialog('option', 'title')`, but in practice that swallows
		// the scriptName and requires `.display`ing, which jumps the
		// window.  It's just a line of text, so this is fine.
		var titleBar = document.querySelector('.ui-dialog-title').firstChild.nextSibling;
		titleBar.nodeValue = titleBar.nodeValue.replace(priorName, relevantUserName);
		// Tweak unblock link
		var unblockLink = document.querySelector('.morebits-dialog-footerlinks a');
		unblockLink.href = unblockLink.href.replace(priorName, relevantUserName);
		unblockLink.title = unblockLink.title.replace(priorName, relevantUserName);

		// Correct partial state
		$form.find('[name=actiontype][value=partial]').prop('checked', Twinkle.getPref('defaultToPartialBlocks'));
		if (blockedUserName === relevantUserName) {
			$form.find('[name=actiontype][value=partial]').prop('checked', Twinkle.block.currentBlockInfo.partial === '');
		}

		// Set content appropriately
		Twinkle.block.callback.change_action(e);
	};

	if (Twinkle.block.fetchedData[relevantUserName]) {
		Twinkle.block.processUserInfo(Twinkle.block.fetchedData[relevantUserName], regenerateForm);
	} else {
		Twinkle.block.fetchUserInfo(regenerateForm);
	}
};

Twinkle.block.callback.change_action = function twinkleblockCallbackChangeAction(e) {
	var field_preset, field_template_options, field_block_options, $form = $(e.target.form);
	// Make ifs shorter
	var blockBox = $form.find('[name=actiontype][value=block]').is(':checked');
	var templateBox = $form.find('[name=actiontype][value=template]').is(':checked');
	var $partial = $form.find('[name=actiontype][value=partial]');
	var partialBox = $partial.is(':checked');
	var blockGroup = partialBox ? Twinkle.block.blockGroupsPartial : Twinkle.block.blockGroups;

	$partial.prop('disabled', !blockBox && !templateBox);

	// Add current block parameters as default preset
	var prior = { label: 'Önceki engel' };
	if (blockedUserName === relevantUserName) {
		Twinkle.block.blockPresetsInfo.prior = Twinkle.block.currentBlockInfo;
		// value not a valid template selection, chosen below by setting templateName
		prior.list = [{ label: 'Önceki engel ayarları', value: 'prior', selected: true }];

		// Arrays of objects are annoying to check
		if (!blockGroup.some(function(bg) {
			return bg.label === prior.label;
		})) {
			blockGroup.push(prior);
		}

		// Always ensure proper template exists/is selected when switching modes
		if (partialBox) {
			Twinkle.block.blockPresetsInfo.prior.templateName = Morebits.string.isInfinity(Twinkle.block.currentBlockInfo.expiry) ? 'Ku-ksüresizengel' : 'Ku-kengel';
		} else {
			if (!Twinkle.block.isRegistered) {
				Twinkle.block.blockPresetsInfo.prior.templateName = 'Ku-anonengel';
			} else {
				Twinkle.block.blockPresetsInfo.prior.templateName = Morebits.string.isInfinity(Twinkle.block.currentBlockInfo.expiry) ? 'Ku-süresizengel' : 'Ku-engel';
			}
		}
	} else {
		// But first remove any prior prior
		blockGroup = blockGroup.filter(function(bg) {
			return bg.label !== prior.label;
		});
	}
	
	// Can be in preset or template field, so the old one in the template
	// field will linger. No need to keep the old value around, so just
	// remove it; saves trouble when hiding/evaluating
	$form.find('[name=dstopic]').parent().remove();

	Twinkle.block.callback.saveFieldset($('[name=field_block_options]'));
	Twinkle.block.callback.saveFieldset($('[name=field_template_options]'));

	if (blockBox) {
		field_preset = new Morebits.quickForm.element({ type: 'field', label: 'Ön ayar', name: 'field_preset' });
		field_preset.append({
			type: 'select',
			name: 'preset',
			label: 'Bir ön ayar seç:',
			event: Twinkle.block.callback.change_preset,
			list: Twinkle.block.callback.filtered_block_groups(blockGroup)
		});

		field_block_options = new Morebits.quickForm.element({ type: 'field', label: 'Engel seçenekleri', name: 'field_block_options' });
		field_block_options.append({ type: 'div', name: 'currentblock', label: ' ' });
		field_block_options.append({ type: 'div', name: 'hasblocklog', label: ' ' });
		field_block_options.append({
			type: 'select',
			name: 'expiry_preset',
			label: 'Bitiş:',
			event: Twinkle.block.callback.change_expiry,
			list: [
				{ label: 'özel', value: 'custom', selected: true },
				{ label: 'süresiz', value: 'infinity' },
				{ label: '3 saat', value: '3 hours' },
				{ label: '12 saat', value: '12 hours' },
				{ label: '24 saat', value: '24 hours' },
				{ label: '32 saat', value: '32 hours' },
				{ label: '36 saat', value: '36 hours' },
				{ label: '48 saat', value: '48 hours' },
				{ label: '60 saat', value: '60 hours' },
				{ label: '72 saat', value: '72 hours' },
				{ label: '1 hafta', value: '1 week' },
				{ label: '2 hafta', value: '2 weeks' },
				{ label: '1 ay', value: '1 month' },
				{ label: '3 ay', value: '3 months' },
				{ label: '6 ay', value: '6 months' },
				{ label: '1 yıl', value: '1 year' },
				{ label: '2 yıl', value: '2 years' },
				{ label: '3 yıl', value: '3 years' }
			]
		});
		field_block_options.append({
			type: 'input',
			name: 'expiry',
			label: 'Özel süre',
			tooltip: 'Göreceli zamanları İngilizce olmak koşuluyla kullanabilirsiniz, örneğin "1 minute", "19 days" veya mutlak zaman damgaları, "yyyymmddhhmm" (örn. "200602011405", 1 Şubat 2006 14:05 UTC idir).',
			value: Twinkle.block.field_block_options.expiry || Twinkle.block.field_template_options.template_expiry
		});

		if (partialBox) { // Partial block
			field_block_options.append({
				type: 'select',
				multiple: true,
				name: 'pagerestrictions',
				label: 'Değiştirmesi engellenecek belirli sayfalar',
				value: '',
				tooltip: 'en fazla 10 sayfa'
			});
			var ns = field_block_options.append({
				type: 'select',
				multiple: true,
				name: 'namespacerestrictions',
				label: 'Ad alanı engelleri',
				value: '',
				tooltip: 'Belirli ad alanlarını değiştirmesini engelleyin.'
			});
			$.each(menuFormattedNamespaces, function(number, name) {
				// Ignore -1: Special; -2: Media; and 2300-2303: Gadget (talk) and Gadget definition (talk)
				if (number >= 0 && number < 830) {
					ns.append({ type: 'option', label: name, value: number });
				}
			});
		}

		var blockoptions = [
			{
				checked: Twinkle.block.field_block_options.nocreate,
				label: 'Hesap oluşturmayı engelle',
				name: 'nocreate',
				value: '1'
			},
			{
				checked: Twinkle.block.field_block_options.noemail,
				label: 'E-posta göndermeyi engelle',
				name: 'noemail',
				value: '1'
			},
			{
				checked: Twinkle.block.field_block_options.disabletalk,
				label: 'Kendi mesaj sayfasını düzenlemesini engelle',
				name: 'disabletalk',
				value: '1',
				tooltip: partialBox ? 'Kısmi engelleme gerçekleştiriyorsanız seçmemeniz tavsiye edilir.' : ''
			}
		];

		if (Twinkle.block.isRegistered) {
			blockoptions.push({
				checked: Twinkle.block.field_block_options.autoblock,
				label: 'Kullanılan tüm IP adreslerini otomatik olarak engelleyin (hardblock)',
				name: 'autoblock',
				value: '1'
			});
		} else {
			blockoptions.push({
				checked: Twinkle.block.field_block_options.hardblock,
				label: 'Giriş yapmış kullanıcıların bu IP adresini kullanmasını engelle (hardblock)',
				name: 'hardblock',
				value: '1'
			});
		}

		blockoptions.push({
			checked: Twinkle.block.field_block_options.watchuser,
			label: 'Kullanıcı sayfasını ve kullanıcı mesaj sayfasını izleyin',
			name: 'watchuser',
			value: '1'
		});

		field_block_options.append({
			type: 'checkbox',
			name: 'blockoptions',
			list: blockoptions
		});
		field_block_options.append({
			type: 'textarea',
			label: 'Gerekçe (engelleme günlüğü için):',
			name: 'reason',
			tooltip: 'Varsayılan mesaja kendiniz ek ayrıntılar eklemeniz tavsiye edilir.',
			value: Twinkle.block.field_block_options.reason
		});

		field_block_options.append({
			type: 'div',
			name: 'filerlog_label',
			label: 'Ayrıca bakınız:',
			style: 'display:inline-block;font-style:normal !important',
			tooltip: 'Engelleme kararında değişiklik süzgecinin veya silinen katkıların bir rol oynayıp oynamadığını belirtmek için "ayrıca bakınız".'
		});
		field_block_options.append({
			type: 'checkbox',
			name: 'filter_see_also',
			event: Twinkle.block.callback.toggle_see_alsos,
			style: 'display:inline-block; margin-right:5px',
			list: [
				{
					label: 'Değişiklik süzgeci',
					checked: false,
					value: 'değişiklik süzgeci'
				}
			]
		});
		field_block_options.append({
			type: 'checkbox',
			name: 'deleted_see_also',
			event: Twinkle.block.callback.toggle_see_alsos,
			style: 'display:inline-block',
			list: [
				{
					label: 'Silinen katkılar',
					checked: false,
					value: 'silinen katkılar'
				}
			]
		});

		// Yet-another-logevents-doesn't-handle-ranges-well
		if (blockedUserName === relevantUserName) {
			field_block_options.append({ type: 'hidden', name: 'reblock', value: '1' });
		}
	}

	// grab discretionary sanctions list from en-wiki
	Twinkle.block.dsinfo = Morebits.wiki.getCachedJson('Template:Ds/topics.json');

	Twinkle.block.dsinfo.then(function(dsinfo) {
		var $select = $('[name="dstopic"]');
		var $options = $.map(dsinfo, function (value, key) {
			return $('<option>').val(value.code).text(key).prop('label', key);
		});
		$select.append($options);
	});
	
	// DS selection visible in either the template field set or preset,
	// joint settings saved here
	var dsSelectSettings = {
		type: 'select',
		name: 'dstopic',
		label: 'DS topic', //DS ne?
		value: '',
		tooltip: 'Seçilirse, şablonla bilgilendirir ve engelleme mesajına eklenebilir',
		event: Twinkle.block.callback.toggle_ds_reason
	};
	
	if (templateBox) {
		field_template_options = new Morebits.quickForm.element({ type: 'field', label: 'Şablon seçenekleri', name: 'field_template_options' });
		field_template_options.append({
			type: 'select',
			name: 'template',
			label: 'Mesaj sayfası için şablon seçin:',
			event: Twinkle.block.callback.change_template,
			list: Twinkle.block.callback.filtered_block_groups(blockGroup, true),
			value: Twinkle.block.field_template_options.template
		});
		
		// Only visible for aeblock and aepblock, toggled in change_template
		field_template_options.append(dsSelectSettings);
		
		field_template_options.append({
			type: 'input',
			name: 'article',
			label: 'Bağlantılı sayfa',
			value: '',
			tooltip: 'Eklenecek şablonun içinde engelin asıl sebebiyse bir sayfaya bağlantı verilebilir. Bağlanacak sayfa olmaması için boş bırakın.'
		});

		// Only visible if partial and not blocking
		field_template_options.append({
			type: 'input',
			name: 'area',
			label: 'Engellenen yerler',
			value: '',
			tooltip: 'Kullanıcının değiştirmesinin engellendiği sayfaların veya ad alanlarının açıklaması. İsteğe bağlı.'
		});

		if (!blockBox) {
			field_template_options.append({
				type: 'input',
				name: 'template_expiry',
				label: 'Engelleme süresi:',
				value: '',
				tooltip: 'Engellemenin kalan süresi, örneğin 24 "saat", 2 hafta, süresiz vb....'//sürenin İngilizce yazılması gerekmediği varsayıldı
			});
		}
		field_template_options.append({
			type: 'input',
			name: 'block_reason',
			label: '"Engellendiniz çünkü ..."',
			tooltip: 'Varsayılan genel nedeni değiştirmek için isteğe bağlı bir neden. Yalnızca genel engel şablonları için kullanılabilir.',
			value: Twinkle.block.field_template_options.block_reason
		});

		if (blockBox) {
			field_template_options.append({
				type: 'checkbox',
				name: 'blank_duration',
				list: [
					{
						label: 'Bitiş tarihini şablona dahil etmeyin',
						checked: Twinkle.block.field_template_options.blank_duration,
						tooltip: 'Süreyi dahil etmek yerine, engel şablonunu "Geçici olarak engellendiniz ..." şeklinde ekleyin.'
					}
				]
			});
		} else {
			field_template_options.append({
				type: 'checkbox',
				list: [
					{
						label: 'Mesaj sayfasına erişim engellendi',
						name: 'notalk',
						checked: Twinkle.block.field_template_options.notalk,
						tooltip: 'Engelleme şablonunda, kullanıcının mesaj sayfasına erişiminin engellendiğini belirtin'
					},
					{
						label: 'E-posta gönderilmesi engellendi',
						name: 'noemail_template',
						checked: Twinkle.block.field_template_options.noemail_template,
						tooltip: 'Engellenen yerler bölümünde belirtilmediyse, engel şablonunda kullanıcının e-posta göndermesinin engellendiğini belirtin'
					},
					{
						label: 'Hesap oluşturulması engellendi',
						name: 'nocreate_template',
						checked: Twinkle.block.field_template_options.nocreate_template,
						tooltip: 'Engellenen yerler bölümünde belirtilmediyse, engel şablonunda kullanıcının hesap oluşturmasının engellendiğini belirtin'
					}
				]
			});
		}

		var $previewlink = $('<a id="twinkleblock-preview-link">Önizleme</a>');
		$previewlink.off('click').on('click', function() {
			Twinkle.block.callback.preview($form[0]);
		});
		$previewlink.css({cursor: 'pointer'});
		field_template_options.append({ type: 'div', id: 'blockpreview', label: [ $previewlink[0] ] });
		field_template_options.append({ type: 'div', id: 'twinkleblock-previewbox', style: 'display: none' });
	} else if (field_preset) {
		// Only visible for arbitration enforcement, toggled in change_preset
		field_preset.append(dsSelectSettings);
	}

	var oldfield;
	if (field_preset) {
		oldfield = $form.find('fieldset[name="field_preset"]')[0];
		oldfield.parentNode.replaceChild(field_preset.render(), oldfield);
	} else {
		$form.find('fieldset[name="field_preset"]').hide();
	}
	if (field_block_options) {
		oldfield = $form.find('fieldset[name="field_block_options"]')[0];
		oldfield.parentNode.replaceChild(field_block_options.render(), oldfield);
		$form.find('fieldset[name="field_64"]').show();


		$form.find('[name=pagerestrictions]').select2({
			width: '100%',
			placeholder: 'Kullanıcının engelleneceği sayfaları seçin',
			language: {
				errorLoading: function() {
					return 'Eksik veya geçersiz arama terimi';
				}
			},
			maximumSelectionLength: 10, // Software limitation [[phab:T202776]]
			minimumInputLength: 1, // prevent ajax call when empty
			ajax: {
				url: mw.util.wikiScript('api'),
				dataType: 'json',
				delay: 100,
				data: function(params) {
					var title = mw.Title.newFromText(params.term);
					if (!title) {
						return;
					}
					return {
						action: 'query',
						format: 'json',
						list: 'allpages',
						apfrom: title.title,
						apnamespace: title.namespace,
						aplimit: '10'
					};
				},
				processResults: function(data) {
					return {
						results: data.query.allpages.map(function(page) {
							var title = mw.Title.newFromText(page.title, page.ns).toText();
							return {
								id: title,
								text: title
							};
						})
					};
				}
			},
			templateSelection: function(choice) {
				return $('<a>').text(choice.text).attr({
					href: mw.util.getUrl(choice.text),
					target: '_blank'
				});
			}
		});


		$form.find('[name=namespacerestrictions]').select2({
			width: '100%',
			matcher: Morebits.select2.matchers.wordBeginning,
			language: {
				searching: Morebits.select2.queryInterceptor
			},
			templateResult: Morebits.select2.highlightSearchMatches,
			placeholder: 'Kullanıcının engelleneceği ad alanlarını seçin'
		});

		mw.util.addCSS(
			// Reduce padding
			'.select2-results .select2-results__option { padding-top: 1px; padding-bottom: 1px; }' +
			// Adjust font size
			'.select2-container .select2-dropdown .select2-results { font-size: 13px; }' +
			'.select2-container .selection .select2-selection__rendered { font-size: 13px; }' +
			// Remove black border
			'.select2-container--default.select2-container--focus .select2-selection--multiple { border: 1px solid #aaa; }' +
			// Make the tiny cross larger
			'.select2-selection__choice__remove { font-size: 130%; }'
		);
	} else {
		$form.find('fieldset[name="field_block_options"]').hide();
		$form.find('fieldset[name="field_64"]').hide();
		// Clear select2 options
		$form.find('[name=pagerestrictions]').val(null).trigger('change');
		$form.find('[name=namespacerestrictions]').val(null).trigger('change');
	}
	if (field_template_options) {
		oldfield = $form.find('fieldset[name="field_template_options"]')[0];
		oldfield.parentNode.replaceChild(field_template_options.render(), oldfield);
		e.target.form.root.previewer = new Morebits.wiki.preview($(e.target.form.root).find('#twinkleblock-previewbox').last()[0]);
	} else {
		$form.find('fieldset[name="field_template_options"]').hide();
	}

	// Any block, including ranges
	if (Twinkle.block.currentBlockInfo) {
		// false for an ip covered by a range or a smaller range within a larger range;
		// true for a user, single ip block, or the exact range for a range block
		var sameUser = blockedUserName === relevantUserName;

		Morebits.status.init($('div[name="currentblock"] span').last()[0]);
		var statusStr = relevantUserName + '' + (Twinkle.block.currentBlockInfo.partial === '' ? 'kısmen engellendi' : 'site çapında engellendi');

		// Range blocked
		if (Twinkle.block.currentBlockInfo.rangestart !== Twinkle.block.currentBlockInfo.rangeend) {
			if (sameUser) {
				statusStr += ' as a rangeblock';
			} else {
				statusStr += ' within a' + (Morebits.ip.get64(relevantUserName) === blockedUserName ? ' /64' : '') + ' rangeblock';
				// Link to the full range
				var $rangeblockloglink = $('<span>').append($('<a target="_blank" href="' + mw.util.getUrl('Special:Log', {action: 'view', page: blockedUserName, type: 'block'}) + '">' + blockedUserName + '</a>)'));
				statusStr += ' (' + $rangeblockloglink.html() + ')';
			}
		}
		if (Twinkle.block.currentBlockInfo.expiry === 'infinity') {
			statusStr += ' (süresiz)';
		} else if (new Morebits.date(Twinkle.block.currentBlockInfo.expiry).isValid()) {
			statusStr += ' (' + new Morebits.date(Twinkle.block.currentBlockInfo.expiry).calendar('utc') + ' tarihinde bitiyor)';
		}
		
		
		var infoStr = 'Bu form';
		if (sameUser) {
			infoStr += ' engeli değiştirecek';
			if (Twinkle.block.currentBlockInfo.partial === undefined && partialBox) {
				infoStr += ', engeli kısmi engele çevirecek';
			} else if (Twinkle.block.currentBlockInfo.partial === '' && !partialBox) {
				infoStr += ', engeli site çapında engele çevirecek';
			}
			infoStr += '.';
		} else {
			infoStr += ' ve ek olarak ' + (partialBox ? 'kısmi ' : '') + 'engel.';
		}

		Morebits.status.warn(statusStr, infoStr);
		
		// Default to the current block conditions on intial form generation
		Twinkle.block.callback.update_form(e, Twinkle.block.currentBlockInfo);
	}
	
	// This is where T146628 really comes into play: a rangeblock will
	// only return the correct block log if wgRelevantUserName is the
	// exact range, not merely a funtional equivalent
	if (Twinkle.block.hasBlockLog) {
		var $blockloglink = $('<span>').append($('<a target="_blank" href="' + mw.util.getUrl('Special:Log', {action: 'view', page: relevantUserName, type: 'block'}) + '">engelleme günlüğü</a>)'));
		if (!Twinkle.block.currentBlockInfo) {
			var lastBlockAction = Twinkle.block.blockLog[0];
			if (lastBlockAction.action === 'unblock') {
				$blockloglink.append(' (unblocked ' + new Morebits.date(lastBlockAction.timestamp).calendar('utc') + ')');
			} else { // block or reblock
				$blockloglink.append(' (' + lastBlockAction.params.duration + ', bitiş ' + new Morebits.date(lastBlockAction.params.expiry).calendar('utc') + ')');
			}
		}

		Morebits.status.init($('div[name="hasblocklog"] span').last()[0]);
		Morebits.status.warn(Twinkle.block.currentBlockInfo ? 'Önceki engeller' : 'Bu ' + (Morebits.ip.isRange(relevantUserName) ? 'aralık' : 'kullanıcı') + ' daha önce engellendi', $blockloglink[0]);
	}

	// Make sure all the fields are correct based on initial defaults
	if (blockBox) {
		Twinkle.block.callback.change_preset(e);
	} else if (templateBox) {
		Twinkle.block.callback.change_template(e);
	}
};


/*
 * Keep alphabetized by key name, Twinkle.block.blockGroups establishes
 *    the order they will appear in the interface
 *
 * Block preset format, all keys accept only 'true' (omit for false) except where noted:
 * <title of block template> : {
 *   autoblock: <autoblock any IP addresses used (for registered users only)>
 *   disabletalk: <disable user from editing their own talk page while blocked>
 *   expiry: <string - expiry timestamp, can include relative times like "5 months", "2 weeks" etc>
 *   forAnonOnly: <show block option in the interface only if the relevant user is an IP>
 *   forRegisteredOnly: <show block option in the interface only if the relevant user is registered>
 *   label: <string - label for the option of the dropdown in the interface (keep brief)>
 *   noemail: prevent the user from sending email through Special:Emailuser
 *   pageParam: <set if the associated block template accepts a page parameter>
 *   prependReason: <string - prepends the value of 'reason' to the end of the existing reason, namely for when revoking talk page access>
 *   nocreate: <block account creation from the user's IP (for anonymous users only)>
 *   nonstandard: <template does not conform to stewardship of WikiProject User Warnings and may not accept standard parameters>
 *   reason: <string - block rationale, as would appear in the block log,
 *            and the edit summary for when adding block template, unless 'summary' is set>
 *   reasonParam: <set if the associated block template accepts a reason parameter>
 *   sig: <string - set to ~~~~ if block template does not accept "true" as the value, or set null to omit sig param altogether>
 *   summary: <string - edit summary for when adding block template to user's talk page, if not set, 'reason' is used>
 *   suppressArticleInSummary: <set to suppress showing the article name in the edit summary, as with attack pages>
 *   templateName: <string - name of template to use (instead of key name), entry will be omitted from the Templates list.
 *                  (e.g. use another template but with different block options)>
 *   useInitialOptions: <when preset is chosen, only change given block options, leave others as they were>
 *
 * WARNING: 'anononly' and 'allowusertalk' are enabled by default.
 *   To disable, set 'hardblock' and 'disabletalk', respectively
 */
Twinkle.block.blockPresetsInfo = {
	'anonblock': {
		expiry: '32 hours',
		forAnonOnly: true,
		nocreate: false,
		nonstandard: true,
		reason: '{{anonengel}}',
		sig: '~~~~'
	},
	'anonblock - school': {
		expiry: '36 hours',
		forAnonOnly: true,
		nocreate: false,
		nonstandard: true,
		reason: '{{anonengel}} <!-- Davranışsal kanıtlar baz alınarak muhtemelen bir okul -->',
		templateName: 'anonblock',
		sig: '~~~~'
	},
	'blocked proxy': {
		expiry: '1 year',
		forAnonOnly: true,
		nocreate: true,
		nonstandard: true,
		hardblock: true,
		reason: '{{blocked proxy}}',
		sig: null
	},
	'CheckUser block': {
		expiry: '1 week',
		forAnonOnly: true,
		nocreate: true,
		nonstandard: true,
		reason: '{{CheckUser block}}',
		sig: '~~~~'
	},
	'checkuserblock-account': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		nonstandard: true,
		reason: '{{checkuserblock-account}}',
		sig: '~~~~'
	},
	'checkuserblock-wide': {
		forAnonOnly: true,
		nocreate: true,
		nonstandard: true,
		reason: '{{checkuserblock-wide}}',
		sig: '~~~~'
	},
	'colocationwebhost': {
		expiry: '1 year',
		forAnonOnly: true,
		nonstandard: true,
		reason: '{{colocationwebhost}}',
		sig: null
	},
	'oversightblock': {
		autoblock: true,
		expiry: 'infinity',
		nocreate: true,
		nonstandard: true,
		reason: '{{OversightBlock}}',
		sig: '~~~~'
	},
	/*'school block': {
		forAnonOnly: true,
		nocreate: true,
		nonstandard: true,
		reason: '{{school block}}',
		sig: '~~~~'
	},*/
	'spamblacklistblock': {
		forAnonOnly: true,
		expiry: '1 month',
		disabletalk: true,
		nocreate: true,
		reason: '{{spamblacklistblock}} <!-- editor only attempts to add blacklisted links, see [[Special:Log/spamblacklist]] -->'
	},
	'rangeblock': {
		reason: '{{rangeblock}}',
		nocreate: true,
		nonstandard: true,
		forAnonOnly: true,
		sig: '~~~~'
	},
	'tor': {
		expiry: '1 year',
		forAnonOnly: true,
		nonstandard: true,
		reason: '{{Tor}}',
		sig: null
	},
	'webhostblock': {
		expiry: '1 year',
		forAnonOnly: true,
		nonstandard: true,
		reason: '{{webhostblock}}',
		sig: null
	},
	// uw-prefixed
	'Ku-3gdengel': {
		autoblock: true,
		expiry: '24 hours',
		nocreate: true,
		pageParam: true,
		reason: '[[VP:3GD|Üç geri dönüş kuralı]] ihlali',
		summary: '[[VP:3GD|Üç geri dönüş kuralını]] ihlal ettiğiniz için değişiklik yapmanız engellendi'
	},
	'Ku-anonengel': {
		autoblock: true,
		expiry: '32 hours',
		forAnonOnly: true,
		nocreate: true,
		pageParam: true,
		reasonParam: true,
		summary: 'IP adresinizin değişiklik yapması engellendi',
		suppressArticleInSummary: true
	},
	'Ku-rengel': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: 'Vikipedi\'yi [[VP:REKLAM|reklam]] amaçlarıyla kullanmak',
		summary: 'Reklamcılık veya kişisel tanıtım yaptığınız için değişiklik yapmanız engellendi'
	},
	/*'uw-aeblock': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: '[[WP:Arbitration enforcement|Arbitration enforcement]]',
		reasonParam: true,
		summary: 'You have been blocked from editing for violating an [[WP:Arbitration|arbitration decision]]'
	},*/
	'Ku-biyoengel': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: '[[VP:YİB|Yaşayan insan biyografileri politikası]] ihlali',
		summary: 'Vikipedi\'nin [[VP:YİB|yaşayan insan biyografileri politikasını]] ihlal ettiğiniz için değişiklik yapmanız engellendi'
	},
	'Ku-engel': {
		autoblock: true,
		expiry: '24 hours',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reasonParam: true,
		summary: 'Değişiklik yapmanız engellendi',
		suppressArticleInSummary: true
	},
	'Ku-süresizengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reasonParam: true,
		summary: 'Değişiklik yapmanız süresiz olarak engellendi',
		suppressArticleInSummary: true
	},
	'Ku-mesajsızengel': {
		disabletalk: true,
		pageParam: true,
		reasonParam: true,
		summary: 'Mesaj sayfanız da dahil olmak üzereDdeğişiklik yapmanız engellendi',
		suppressArticleInSummary: true
	},
	'Ku-botengel': {
		forRegisteredOnly: true,
		pageParam: true,
		reason: '[[VP:BOTB|Onaylanmamış]] [[VP:BOT|bot sistemleri]] çalıştırmak',
		summary: '[[VP:BOTB|Onaylanmamış]] [[VP:BOT|bot sistemleri]] çalıştırmanız nedeniyle değişiklik yapmanız engellendi.'
	},
	'Ku-botka': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{Ku-botka}} <!-- Kullanıcı adı bir botu ima ediyor, yumuşak engel -->',
		summary: 'Kullanıcı adınız şu anda [[VP:BOTB|onaylanmamış]] bir [[VP:BOT|bot hesabı]] olduğunu gösterdiğinden, değişiklik yapmanız süresiz olarak engellendi.'
	},
	'Ku-botkat': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: '{{Ku-botkat}} <!-- Kullanıcı adı bir botu ima ediyor, sert engel -->',
		summary: 'Kullanıcı adınız [[VP:KA|kullanıcı adı politikasını]] açıkça ihlal ettiği için değişiklik yapmanız süresiz olarak engellendi.'
	},
	/*'uw-causeblock': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{uw-causeblock}} <!-- Username represents a non-profit, soft block -->',
		summary: 'You have been indefinitely blocked from editing because your [[WP:U|username]] gives the impression that the account represents a group, organization or website'
	},*/
	/*'uw-compblock': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: 'Compromised account',
		summary: 'You have been indefinitely blocked from editing because it is believed that your [[WP:SECURE|account has been compromised]]'
	},*/
	'Ku-telifengel': {
		autoblock: true,
		expiry: 'infinity',
		nocreate: true,
		pageParam: true,
		reason: 'Telif hakkı ihlalleri',
		summary: 'Devam eden telif hakkı ihlalleri nedeniyle değişiklik yapmanız engellendi'
	},
	'Ku-silengel': {
		autoblock: true,
		nocreate: true,
		reason: 'İçeriğin ısrarla kaldırılması',
		pageParam: true,
		summary: '[[VP:V|İçeriği sürekli olarak kaldırdığınız]] için değişiklik yapmanız engellendi'
	},
	'Ku-aksatengel': {
		autoblock: true,
		nocreate: true,
		reason: 'Aksatıcı değişiklikler',
		summary: 'Aksatıcı değişiklikler yapmanız nedeniyle değişiklik yapmanız engellendi'
	},
	'Ku-süzgeçengel': {
		autoblock: true,
		nocreate: true,
		reason: 'Defalarca değişiklik süzgecini tetiklemek',
		summary: 'Değişiklik süzgecini tetikleyen zararlı değişlikler yapmaya çalıştığınız için değişiklik yapmanız engellendi.'
	},
	'Ku-savaşengel': {
		autoblock: true,
		expiry: '24 hours',
		nocreate: true,
		pageParam: true,
		reason: '[[VP:DS|Değişiklik savaşı]]',
		summary: '[[VP:DS|Değişiklik savaşına]] girdiğinizi için değişiklik yapmanız engellendi'
	},
	'Ku-tacizengel': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: '[[Vikipedi:İçerik üzerine yorum yapınız, katılımcı üzerine değil|Kişisel saldırı]] veya [[Vikipedi:Taciz|taciz]]',
		summary: 'Diğer kullanıcıları [[Vikipedi:Taciz|taciz etmeye]] çalıştığınız için değişiklik yapmanız engellendi'
	},
	'Ku-ipkaçengel': {
		forAnonOnly: true,
		nocreate: true,
		reason: 'Engelden kaçınmak',
		summary: 'IP adresinizin bir engelden kaçmak için kullanıldığından değişiklik yapması engellendi'
	},
	'Ku-yasalengel': {
		autoblock: true,
		expiry: 'infinity',
		nocreate: true,
		reason: '[[Vikipedi:Hukuki tehditler yasaktır|Hukuki tehditler]]',
		summary: '[[Vikipedi:Hukuki tehditler yasaktır|Hukuki tehditlerde bulunduğunuz veya yasal işlem başlattığınız]] için değişiklik yapmanız engellendi'
	},
	'Ku-buralıdeğilengel': {
		autoblock: true,
		expiry: 'infinity',
		nocreate: true,
		reason: 'Açıkça bir ansiklopedi oluşturmak için burada değil',
		forRegisteredOnly: true,
		summary: 'Ansiklopedi oluşturmak için burada olmadığınız görüldüğü için değişiklik yapmanız süresiz olarak engellendi'
	},
	/*'uw-npblock': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: 'Creating [[WP:Patent nonsense|patent nonsense]] or other inappropriate pages',
		summary: 'You have been blocked from editing for creating [[WP:PN|nonsense pages]]'
	},*/
	'Ku-ksengel': {
		autoblock: true,
		expiry: '32 hours',
		nocreate: true,
		reason: '[[VP:İÜYYKÜD|Kişisel saldırılar]] veya [[VP:TA|taciz]]',
		summary: 'Diğer kullanıcılara karşı [[VP:İÜYYKÜD|kişisel saldırılar]] yapmanız nedeniyle değişiklik yapmanız engellendi'
	},
	'Ku-bağengel': {
		autoblock: true,
		nocreate: true,
		reason: 'Vikipedi\'yi reklam bağlantıları eklemek amaçlı kullanmak',
		summary: 'Vikipedi\yi reklam bağlantıları eklemek amaçlı kullandığınız için değişiklik yapmanız engellendi'
	},
	'Ku-sbağengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reason: 'Sadece [[Vikipedi:Reklam|reklam]] amaçlı hesap',
		summary: 'Hesabınız yalnızca reklam veya tanıtım amacıyla kullanıldığı için değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-sosyalmedyaengel': {
		autoblock: true,
		nocreate: true,
		pageParam: true,
		reason: 'Vikipedi\'yi [[Vikipedi:Vikipedi ne değildir?|blog, web sunucusu, sosyal ağ sitesi veya forum olarak kullanmak]]',
		summary: 'Vikipedi\'yi [[Vikipedi:Vikipedi ne değildir?|blog, web sunucusu, sosyal ağ sitesi veya forum olarak kullandığınız]] için değişiklik yapmanız engellendi'
	},
	'Ku-kuklaengel': {
		autoblock: true,
		forRegisteredOnly: true,
		nocreate: true,
		reason: '[[VP:KUKLA|Birden çok hesabı]] kötüye kullanmak',
		summary: '[[VP:KUKLA|Birden çok hesabı]] kötüye kullandığınız için değişiklik yapmanız engellendi'
	},
	'Ku-hafifengel': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{Ku-hafifengel}} <!-- Tanıtım amaçlı kullanıcı adı, yumuşak engel -->',
		summary: '[[VP:KA|Kullanıcı adınız]], hesabınızın bir grubu, kuruluşu veya web sitesini temsil ettiği izlenimini verdiği için değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-reklamkaengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: '{{Ku-reklamkaengel}} <!-- Tanıtım amaçlı kullanıcı adı, Tanıtım amaçlı değişiklikler -->',
		summary: 'Hesabınızın yalnızca reklam amaçlı kullanılması ve kullanıcı adınız [[VP:KA|kullanıcı adı politikasını]] ihlal etmesi nedeniyle değişiklik yapmanız süresiz olarak engellendi'
	},
	/*'uw-spoablock': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: '[[WP:SOCK|Sock puppetry]]',
		summary: 'This account has been blocked as a [[WP:SOCK|sock puppet]] created to violate Wikipedia policy'
	},*/
	/*'uw-talkrevoked': {
		disabletalk: true,
		reason: 'Revoking talk page access: inappropriate use of user talk page while blocked',
		prependReason: true,
		summary: 'Your user talk page access has been disabled',
		useInitialOptions: true
	},*/
	'Ku-kaengel': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{Ku-kaengel}} <!-- Kullanıcı adı ihlali, yumuşak engel -->',
		reasonParam: true,
		summary: 'Kullanıcı adınız [[VP:KA|kullanıcı adı politikasını]] ihlal ettiği için değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-kaengel-benzer': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{Ku-kaengel-benzer}} <!-- Kullanıcı adı başka bir kullanıcıya çok benziyor, yumuşak engel -->',
		summary: 'Kullanıcı adınız başka bir Vikipedi kullanıcısının kullanıcı adına çok benzediği için değişiklik yapmanız süresiz olarak engellendi'
	},
	/*'uw-ucblock': {
		autoblock: true,
		expiry: '32 hours',
		nocreate: true,
		pageParam: true,
		reason: 'Persistent addition of [[WP:INTREF|unsourced content]]',
		summary: 'You have been blocked from editing for persistent addition of [[WP:INTREF|unsourced content]]'
	},*/
	'Ku-tacizka': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: '{{Ku-tacizka}} <!-- Kullanıcı adı ihlali, sert engel -->',
		reasonParam: true,
		summary: 'Kullanıcı adınız [[VP:KA|kullanıcı adı politikasını]] bariz bir şekilde ihlal ettiği için değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-kaengel-ünlü': {
		expiry: 'infinity',
		forRegisteredOnly: true,
		reason: '{{Ku-kaengel-ünlü}} <!-- Kullanıcı adı ünlü birini temsil ediyor, yumuşak engel -->',
		summary: 'Kullanıcı adınız yaşayan ünlü bir kişinin adıyla aynı olduğu için değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-kaengel-benzert': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		reason: '{{Ku-kaengel-benzer}} <!-- Başka bir kullanıcının kimliğine bürünme girişimi , sert engel -->',
		summary: 'Kullanıcı adınızla başka bir Vikipedi kullanıcısını taklit ediyor gibi gözüktüğünüz için değişiklik yapmanız süresiz olarak engellendi'
	},
	/*'uw-upeblock': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reason: '[[WP:PAID|Undisclosed paid editing]] in violation of the WMF [[WP:TOU|Terms of Use]]',
		summary: 'You have been indefinitely blocked from editing because your account is being used in violation of [[WP:PAID|Wikipedia policy on undisclosed paid advocacy]]'
	},*/
	'Ku-vahkaengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reason: '{{Ku-vahkaengel}} <!-- Kullanıcı adı ihlali, sadece vandalizm amaçlı hesap -->',
		summary: 'Hesabınızın [[VP:VAH|yalnızca vandalizm amacıyla kullanıldığından]] ve kullanıcı adınızın [[VP:KA|kullanıcı adı politikası]] bariz bir şekilde ihlal ettiğinden değişiklik yapmanız süresiz olarak engellendi'
	},
	'Ku-vandalengel': {
		autoblock: true,
		expiry: '32 hours',
		nocreate: true,
		pageParam: true,
		reason: '[[VP:V|Vandalizm]]',
		summary: 'Daha fazla [[VP:V|vandalizm]] yapmanızı önlemek için değişiklik yapmanız engellendi'
	},
	'Ku-svandalengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: true,
		reason: '[[VP:VAH|Sadece vandalizm amaçlı hesap]]',
		summary: '[[VP:VAH|Hesabınızın yalnızca vandalizm için kullanıldığından]], değişiklik yapmanız süresiz olarak engellendi'
	},
	'zombie proxy': {
		expiry: '1 month',
		forAnonOnly: true,
		nocreate: true,
		nonstandard: true,
		reason: '{{zombie proxy}}',
		sig: null
	},

	// Begin partial block templates, accessed in Twinkle.block.blockGroupsPartial
	'Ku-hesapengel': {
		autoblock: true,
		expiry: '48 hours',
		nocreate: true,
		pageParam: false,
		reasonParam: true,
		reason: '[[VP:KUKLA|Birden çok hesabı]] kötüye kullanmak',
		summary: '[[VP:KUKLA|Birden fazla hesabı kötüye kullandığınız]] için [[VP:KE|hesap oluşturmanız engellendi]]'
	},
	'Ku-hesapengelsüresiz': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: true,
		pageParam: false,
		reasonParam: true,
		reason: '[[VP:KUKLA|Birden çok hesabı]] kötüye kullanmak',
		summary: '[[VP:KUKLA|Birden fazla hesabı kötüye kullandığınız]] için [[VP:KE|hesap oluşturmanız süresiz olarak engellendi]]'
	},
	/*'uw-aepblock': {
		autoblock: true,
		nocreate: false,
		pageParam: false,
		reason: '[[WP:Arbitration enforcement|Arbitration enforcement]]',
		reasonParam: true,
		summary: 'You have been [[WP:PB|partially blocked]] from editing for violating an [[WP:Arbitration|arbitration decision]]'
	},*/
	'Ku-epostaengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: false,
		noemail: true,
		pageParam: false,
		reasonParam: true,
		reason: 'E-posta [[VP:TA|tacizi]]',
		summary: '[[VP:TA|Taciz]] nedeniyle diğer kullanıcılara [[VP:KE|e-posta göndermeniz engellendi]]'
	},
	'Ku-ksavaşengel': {
		autoblock: true,
		expiry: '24 hours',
		nocreate: false,
		pageParam: false,
		reasonParam: true,
		reason: '[[VP:DS|Değişiklik savaşı]]',
		summary: '[[VP:DS|Değişiklik savaşı]] nedeniyle ansiklopedinin belirli alanlarını değişiklik yapmanız [[VP:KE|kısmen engellendi]]'
	},
	'Ku-kengel': {
		autoblock: true,
		expiry: '24 hours',
		nocreate: false,
		pageParam: false,
		reasonParam: true,
		summary: 'Ansiklopedinin belirli alanlarından [[VP:KE|kısmen engellendiniz]]'
	},
	'Ku-ksüresizengel': {
		autoblock: true,
		expiry: 'infinity',
		forRegisteredOnly: true,
		nocreate: false,
		pageParam: false,
		reasonParam: true,
		summary: 'Ansiklopedinin belirli alanlarından süresiz olarak [[VP:KE|kısmen engellendiniz]]'
	}
};

Twinkle.block.transformBlockPresets = function twinkleblockTransformBlockPresets() {
	// supply sensible defaults
	$.each(Twinkle.block.blockPresetsInfo, function(preset, settings) {
		settings.summary = settings.summary || settings.reason;
		settings.sig = settings.sig !== undefined ? settings.sig : 'evet';
		settings.indefinite = settings.indefinite || Morebits.string.isInfinity(settings.expiry);

		if (!Twinkle.block.isRegistered && settings.indefinite) {
			settings.expiry = '32 hours';
		} else {
			settings.expiry = settings.expiry || '32 hours';
		}

		Twinkle.block.blockPresetsInfo[preset] = settings;
	});
};

// These are the groups of presets and defines the order in which they appear. For each list item:
//   label: <string, the description that will be visible in the dropdown>
//   value: <string, the key of a preset in blockPresetsInfo>
Twinkle.block.blockGroups = [
	{
		label: 'Yaygın engelleme nedenleri',
		list: [
			{ label: 'Anonengel', value: 'anonblock' },
			{ label: 'Anonengel - muhtemelen bir okul', value: 'anonblock - school' },
			//{ label: 'okul engel', value: 'school block' },
			{ label: 'Genel engel (özel gerekçe)', value: 'Ku-engel' }, // ends up being default for registered users
			{ label: 'Genel engel (özel gerekçe) - IP', value: 'Ku-anonengel', selected: true }, // set only when blocking IP
			{ label: 'Genel engel (özel gerekçe) - süresiz', value: 'Ku-süresizengel' },
			{ label: 'Aksatıcı değişiklik', value: 'Ku-aksatengel' },
			//{ label: 'Engelliyken mesaj sayfasının uygunsuz kullanımı', value: 'uw-talkrevoked' },
			{ label: 'Bir ansiklopedi oluşturmak için burada değil', value: 'Ku-buralıdeğilengel' },
			//{ label: 'Unsourced content', value: 'uw-ucblock' },
			{ label: 'Vandalizm', value: 'Ku-vandalengel' },
			{ label: 'Sadece vandalizm amaçlı hesap', value: 'Ku-svandalengel' }
		]
	},
	{
		label: 'Ayrıntılı nedenler',
		list: [
			{ label: 'Reklamcılık', value: 'Ku-rengel' },
			//{ label: 'Arbitration enforcement', value: 'uw-aeblock' },
			{ label: 'Engelden kaçma - IP', value: 'Ku-ipkaçengel' },
			{ label: 'YİB ihlalleri', value: 'Ku-biyoengel' },
			{ label: 'Telif hakkı ihlalleri', value: 'Ku-telifengel' },
			//{ label: 'Creating nonsense pages', value: 'uw-npblock' },
			{ label: 'Değişiklik süzgeci engeli', value: 'Ku-süzgeçengel' },
			{ label: 'Değişiklik savaşı', value: 'Ku-savaşengel' },
			{ label: 'Mesaj sayfası erişimi olmayan genel engel', value: 'Ku-mesajsızengel' },
			{ label: 'Taciz', value: 'Ku-tacizengel' },
			{ label: 'Hukuki tehdit', value: 'Ku-yasalengel' },
			{ label: 'Kişisel saldırılar veya taciz', value: 'Ku-ksengel' },
			//{ label: 'Possible compromised account', value: 'uw-compblock' },
			{ label: 'İçeriği kaldırma', value: 'Ku-silengel' },
			{ label: 'Kuklacılık (kuklacı)', value: 'Ku-kuklaengel' },
			//{ label: 'Kuklacılık (kukla)', value: 'uw-spoablock' }, // Bu şablon oluşturulmalı
			{ label: 'Sosyal medyacılık', value: 'Ku-sosyalmedyaengel' },
			{ label: 'Reklam bağlantıları eklemek', value: 'Ku-bağengel' },
			{ label: 'Sadece reklam amaçlı hesap', value: 'Ku-sbağengel' },
			{ label: 'Onaylanmamış bot', value: 'Ku-botengel' },
			//{ label: 'Undisclosed paid editing', value: 'uw-upeblock' },
			{ label: 'Üç geri dönüş kuralı ihlali', value: 'Ku-3gdengel' }
		]
	},
	{
		label: 'Kullanıcı adı politikası ihlalleri',
		list: [
			{ label: 'Bot kullanıcı adı, yumuşak engel', value: 'Ku-botka' },
			{ label: 'Bot kullanıcı adı, sert engel', value: 'Ku-botkat' },
			{ label: 'Reklam kullanıcı adı, sert engel', value: 'Ku-reklamkaengel' },
			{ label: 'Reklam kullanıcı adı, yumuşak engel', value: 'Ku-hafifengel' },
			{ label: 'Benzer kullanıcı adı, yumuşak engel', value: 'Ku-kaengel-benzer' },
			{ label: 'Kullanıcı adı ihlali, yumuşak engel', value: 'Ku-kaengel' },
			{ label: 'Kullanıcı adı ihlali, sert engel', value: 'Ku-tacizka' },
			{ label: 'Kullanıcı kimliğine bürünme, sert engel', value: 'Ku-kaengel-benzert' },
			{ label: 'Ünlü kişi kullanıcı adı, yumuşak engel', value: 'Ku-kaengel-ünlü' },
			//{ label: 'Username represents a non-profit, soft block', value: 'uw-causeblock' },
			{ label: 'Kullanıcı adı ihlali, sadece vandalizm amaçlı hesap', value: 'Ku-vahkaengel' }
		]
	}/*,
	{
		label: 'Şablonlu nedenler',
		list: [
			{ label: 'blocked proxy', value: 'blocked proxy' },
			{ label: 'CheckUser block', value: 'CheckUser block' },
			{ label: 'checkuserblock-account', value: 'checkuserblock-account' },
			{ label: 'checkuserblock-wide', value: 'checkuserblock-wide' },
			{ label: 'colocationwebhost', value: 'colocationwebhost' },
			{ label: 'oversightblock', value: 'oversightblock' },
			{ label: 'rangeblock', value: 'rangeblock' }, // Only for IP ranges, selected for non-/64 ranges in filtered_block_groups
			{ label: 'spamblacklistblock', value: 'spamblacklistblock' },
			{ label: 'tor', value: 'tor' },
			{ label: 'webhostblock', value: 'webhostblock' },
			{ label: 'zombie proxy', value: 'zombie proxy' }
		]
	}*/
];

Twinkle.block.blockGroupsPartial = [
	{
		label: 'Yaygın kısmi engelleme nedenleri',
		list: [
			{ label: 'Genel kısmi engel (özel gerekçe)', value: 'Ku-kengel', selected: true },
			{ label: 'Genel kısmi engel (özel gerekçe) - süresiz', value: 'Ku-ksüresizengel' },
			{ label: 'Değişiklik savaşı', value: 'Ku-ksavaşengel' }
		]
	},
	{
		label: 'Ayrıntılı kısmi engelleme nedenleri',
		list: [
			//{ label: 'Arbitration enforcement', value: 'uw-aepblock' },
			{ label: 'E-posta tacizi', value: 'Ku-epostaengel' },
			{ label: 'Birden çok hesabı kötüye kullanma', value: 'Ku-hesapengel' },
			{ label: 'Birden çok hesabı kötüye kullanma - süresiz', value: 'Ku-hesapengelsüresiz' }
		]
	}
];


Twinkle.block.callback.filtered_block_groups = function twinkleblockCallbackFilteredBlockGroups(group, show_template) {
	return $.map(group, function(blockGroup) {
		var list = $.map(blockGroup.list, function(blockPreset) {
			switch (blockPreset.value) {
				case 'uw-talkrevoked':
					if (blockedUserName !== relevantUserName) {
						return;
					}
					break;
				case 'rangeblock':
					if (!Morebits.ip.isRange(relevantUserName)) {
						return;
					}
					blockPreset.selected = !Morebits.ip.get64(relevantUserName);
					break;
				case 'CheckUser block':
				case 'checkuserblock-account':
				case 'checkuserblock-wide':
					if (!Morebits.userIsInGroup('checkuser')) {
						return;
					}
					break;
				case 'oversightblock':
					if (!Morebits.userIsInGroup('suppress')) {
						return;
					}
					break;
				default:
					break;
			}

			var blockSettings = Twinkle.block.blockPresetsInfo[blockPreset.value];

			var registrationRestrict;
			if (blockSettings.forRegisteredOnly) {
				registrationRestrict = Twinkle.block.isRegistered;
			} else if (blockSettings.forAnonOnly) {
				registrationRestrict = !Twinkle.block.isRegistered;
			} else {
				registrationRestrict = true;
			}

			if (!(blockSettings.templateName && show_template) && registrationRestrict) {
				var templateName = blockSettings.templateName || blockPreset.value;
				return {
					label: (show_template ? '{{' + templateName + '}}: ' : '') + blockPreset.label,
					value: blockPreset.value,
					data: [{
						name: 'template-name',
						value: templateName
					}],
					selected: !!blockPreset.selected,
					disabled: !!blockPreset.disabled
				};
			}
		});
		if (list.length) {
			return {
				label: blockGroup.label,
				list: list
			};
		}
	});
};

Twinkle.block.callback.change_preset = function twinkleblockCallbackChangePreset(e) {
	var form = e.target.form, key = form.preset.value;
	if (!key) {
		return;
	}

	Twinkle.block.callback.update_form(e, Twinkle.block.blockPresetsInfo[key]);
	if (form.template) {
		form.template.value = Twinkle.block.blockPresetsInfo[key].templateName || key;
		Twinkle.block.callback.change_template(e);
	} else {
		Morebits.quickForm.setElementVisibility(form.dstopic.parentNode, key === 'uw-aeblock' || key === 'uw-aepblock');
	}
};

Twinkle.block.callback.change_expiry = function twinkleblockCallbackChangeExpiry(e) {
	var expiry = e.target.form.expiry;
	if (e.target.value === 'custom') {
		Morebits.quickForm.setElementVisibility(expiry.parentNode, true);
	} else {
		Morebits.quickForm.setElementVisibility(expiry.parentNode, false);
		expiry.value = e.target.value;
	}
};

Twinkle.block.seeAlsos = [];
Twinkle.block.callback.toggle_see_alsos = function twinkleblockCallbackToggleSeeAlso() {
	var reason = this.form.reason.value.replace(
		new RegExp('( <!--|;) ' + 'ayrıca bakınız ' + Twinkle.block.seeAlsos.join(' ve ') + '( -->)?'), ''
	);

	Twinkle.block.seeAlsos = Twinkle.block.seeAlsos.filter(function(el) {
		return el !== this.value;
	}.bind(this));

	if (this.checked) {
		Twinkle.block.seeAlsos.push(this.value);
	}
	var seeAlsoMessage = Twinkle.block.seeAlsos.join(' ve ');

	if (!Twinkle.block.seeAlsos.length) {
		this.form.reason.value = reason;
	} else if (reason.indexOf('{{') !== -1) {
		this.form.reason.value = reason + ' <!-- ayrıca bakınız ' + seeAlsoMessage + ' -->';
	} else {
		this.form.reason.value = reason + '; ayrıca bakınız ' + seeAlsoMessage;
	}
};

Twinkle.block.dsReason = '';
Twinkle.block.callback.toggle_ds_reason = function twinkleblockCallbackToggleDSReason() {
	var reason = this.form.reason.value.replace(
		new RegExp(' ?\\(\\[\\[' + Twinkle.block.dsReason + '\\]\\]\\)'), ''
	);

	Twinkle.block.dsinfo.then(function(dsinfo) {
		var sanctionCode = this.selectedIndex;
		var sanctionName = this.options[sanctionCode].label;
		Twinkle.block.dsReason = dsinfo[sanctionName].page;
		if (!this.value) {
			this.form.reason.value = reason;
		} else {
			this.form.reason.value = reason + ' ([[' + Twinkle.block.dsReason + ']])';
		}
	}.bind(this));
};

Twinkle.block.callback.update_form = function twinkleblockCallbackUpdateForm(e, data) {
	var form = e.target.form, expiry = data.expiry;

	// don't override original expiry if useInitialOptions is set
	if (!data.useInitialOptions) {
		if (Date.parse(expiry)) {
			expiry = new Date(expiry).toGMTString();
			form.expiry_preset.value = 'custom';
		} else {
			form.expiry_preset.value = data.expiry || 'custom';
		}

		form.expiry.value = expiry;
		if (form.expiry_preset.value === 'custom') {
			Morebits.quickForm.setElementVisibility(form.expiry.parentNode, true);
		} else {
			Morebits.quickForm.setElementVisibility(form.expiry.parentNode, false);
		}
	}

	// boolean-flipped options, more at [[mw:API:Block]]
	data.disabletalk = data.disabletalk !== undefined ? data.disabletalk : false;
	data.hardblock = data.hardblock !== undefined ? data.hardblock : false;

	// disable autoblock if blocking a bot
	if (Twinkle.block.userIsBot || /bot\b/i.test(relevantUserName)) {
		data.autoblock = false;
	}

	$(form).find('[name=field_block_options]').find(':checkbox').each(function(i, el) {
		// don't override original options if useInitialOptions is set
		if (data.useInitialOptions && data[el.name] === undefined) {
			return;
		}

		var check = data[el.name] === '' || !!data[el.name];
		$(el).prop('checked', check);
	});

	if (data.prependReason && data.reason) {
		form.reason.value = data.reason + '; ' + form.reason.value;
	} else {
		form.reason.value = data.reason || '';
	}
	
		// Clear and/or set any partial page or namespace restrictions
	if (form.pagerestrictions) {
		var $pageSelect = $(form).find('[name=pagerestrictions]');
		var $namespaceSelect = $(form).find('[name=namespacerestrictions]');

		// Respect useInitialOptions by clearing data when switching presets
		// In practice, this will always clear, since no partial presets use it
		if (!data.useInitialOptions) {
			$pageSelect.val(null).trigger('change');
			$namespaceSelect.val(null).trigger('change');
		}

		// Add any preset options; in practice, just used for prior block settings
		if (data.restrictions) {
			if (data.restrictions.pages && !$pageSelect.val().length) {
				var pages = data.restrictions.pages.map(function(pr) {
					return pr.title;
				});
				// since page restrictions use an ajax source, we
				// short-circuit that and just add a new option
				pages.forEach(function(page) {
					if (!$pageSelect.find("option[value='" + $.escapeSelector(page) + "']").length) {
						var newOption = new Option(page, page, true, true);
						$pageSelect.append(newOption);
					}
				});
				$pageSelect.val($pageSelect.val().concat(pages)).trigger('change');
			}
			if (data.restrictions.namespaces) {
				$namespaceSelect.val($namespaceSelect.val().concat(data.restrictions.namespaces)).trigger('change');
			}
		}
	}
};

Twinkle.block.callback.change_template = function twinkleblockcallbackChangeTemplate(e) {
	var form = e.target.form, value = form.template.value, settings = Twinkle.block.blockPresetsInfo[value];

	var blockBox = $(form).find('[name=actiontype][value=block]').is(':checked');
	var partialBox = $(form).find('[name=actiontype][value=partial]').is(':checked');
	var templateBox = $(form).find('[name=actiontype][value=template]').is(':checked');

	// Block form is not present
	if (!blockBox) {
		if (settings.indefinite || settings.nonstandard) {
			if (Twinkle.block.prev_template_expiry === null) {
				Twinkle.block.prev_template_expiry = form.template_expiry.value || '';
			}
			form.template_expiry.parentNode.style.display = 'none';
			form.template_expiry.value = 'infinity';
		} else if (form.template_expiry.parentNode.style.display === 'none') {
			if (Twinkle.block.prev_template_expiry !== null) {
				form.template_expiry.value = Twinkle.block.prev_template_expiry;
				Twinkle.block.prev_template_expiry = null;
			}
			form.template_expiry.parentNode.style.display = 'block';
		}
		if (Twinkle.block.prev_template_expiry) {
			form.expiry.value = Twinkle.block.prev_template_expiry;
		}
		Morebits.quickForm.setElementVisibility(form.notalk.parentNode, !settings.nonstandard);
		// Partial
		Morebits.quickForm.setElementVisibility(form.noemail_template.parentNode, partialBox);
		Morebits.quickForm.setElementVisibility(form.nocreate_template.parentNode, partialBox);
	} else if (templateBox) { // Only present if block && template forms both visible
		Morebits.quickForm.setElementVisibility(
			form.blank_duration.parentNode,
			!settings.indefinite && !settings.nonstandard
		);
	}

	Morebits.quickForm.setElementVisibility(form.dstopic.parentNode, value === 'uw-aeblock' || value === 'uw-aepblock');
	// ^ iki şablon da bizde yok

	// Only particularly relevant if template form is present
	Morebits.quickForm.setElementVisibility(form.article.parentNode, settings && !!settings.pageParam);
	Morebits.quickForm.setElementVisibility(form.block_reason.parentNode, settings && !!settings.reasonParam);

	// Partial block
	Morebits.quickForm.setElementVisibility(form.area.parentNode, partialBox && !blockBox);

	form.root.previewer.closePreview();
};
Twinkle.block.prev_template_expiry = null;

Twinkle.block.callback.preview = function twinkleblockcallbackPreview(form) {
	var params = {
		article: form.article.value,
		blank_duration: form.blank_duration ? form.blank_duration.checked : false,
		disabletalk: form.disabletalk.checked || (form.notalk ? form.notalk.checked : false),
		expiry: form.template_expiry ? form.template_expiry.value : form.expiry.value,
		hardblock: Twinkle.block.isRegistered ? form.autoblock.checked : form.hardblock.checked,
		indefinite: Morebits.string.isInfinity(form.template_expiry ? form.template_expiry.value : form.expiry.value),
		reason: form.block_reason.value,
		template: form.template.value,
		dstopic: form.dstopic.value,
		partial: $(form).find('[name=actiontype][value=partial]').is(':checked'),
		pagerestrictions: $(form.pagerestrictions).val() || [],
		namespacerestrictions: $(form.namespacerestrictions).val() || [],
		noemail: form.noemail.checked || (form.noemail_template ? form.noemail_template.checked : false),
		nocreate: form.nocreate.checked || (form.nocreate_template ? form.nocreate_template.checked : false),
		area: form.area.value
	};

	var templateText = Twinkle.block.callback.getBlockNoticeWikitext(params);

	form.previewer.beginRender(templateText, 'User_talk:' + relevantUserName); // Force wikitext/correct username
};

Twinkle.block.callback.evaluate = function twinkleblockCallbackEvaluate(e) {
	var $form = $(e.target),
		toBlock = $form.find('[name=actiontype][value=block]').is(':checked'),
		toWarn = $form.find('[name=actiontype][value=template]').is(':checked'),
		toPartial = $form.find('[name=actiontype][value=partial]').is(':checked'),
		blockoptions = {}, templateoptions = {};

	Twinkle.block.callback.saveFieldset($form.find('[name=field_block_options]'));
	Twinkle.block.callback.saveFieldset($form.find('[name=field_template_options]'));

	blockoptions = Twinkle.block.field_block_options;

	templateoptions = Twinkle.block.field_template_options;
	templateoptions.disabletalk = !!(templateoptions.disabletalk || blockoptions.disabletalk);
	templateoptions.hardblock = !!blockoptions.hardblock;
	
	delete blockoptions.expiry_preset; // remove extraneous

	// Partial API requires this to be gone, not false or 0
	if (toPartial) {
		blockoptions.partial = templateoptions.partial = true;
	}
	templateoptions.pagerestrictions = $form.find('[name=pagerestrictions]').val() || [];
	templateoptions.namespacerestrictions = $form.find('[name=namespacerestrictions]').val() || [];
	// Format for API here rather than in saveFieldset
	blockoptions.pagerestrictions = templateoptions.pagerestrictions.join('|');
	blockoptions.namespacerestrictions = templateoptions.namespacerestrictions.join('|');

	// use block settings as warn options where not supplied
	templateoptions.summary = templateoptions.summary || blockoptions.reason;
	templateoptions.expiry = templateoptions.template_expiry || blockoptions.expiry;

	if (toBlock) {
		if (blockoptions.partial) {
			if (blockoptions.disabletalk && blockoptions.namespacerestrictions.indexOf('3') === -1) {
				return alert('Kısmi engeller, "Kullanıcı mesaj" ad alanını değiştirmeleri engellenmedikçe kendi mesaj sayfasını değiştirmeyi engelleyemez!');
			}
			if (!blockoptions.namespacerestrictions && !blockoptions.pagerestrictions) {
				if (!blockoptions.noemail && !blockoptions.nocreate) { // Blank entries technically allowed [[phab:T208645]]
					return alert('Hiçbir sayfa veya ad alanı seçilmedi ve e-posta veya hesap oluşturma kısıtlamaları uygulanmadı; kısmi engel uygulamak için lütfen bunlardan en az bir tanesini seçin!');
				} else if ((templateoptions.template !== 'Ku-epostaengel' || $form.find('select[name="preset"]').val() !== 'Ku-epostaengel') &&
					// Don't require confirmation if email harassment defaults are set
					!confirm('Kullanıcıyı, herhangi bir sayfa veya ad alanı değiştirmesinde hiçbir kısıtlama olmaksızın engellemek üzeresiniz. Devam etmek istediğinizden emin misiniz?')) {
					return;
				}
			}
		}
		if (!blockoptions.expiry) {
			return alert('Lütfen bir bitiş tarihi girin!');
		} else if (Morebits.string.isInfinity(blockoptions.expiry) && !Twinkle.block.isRegistered) {
			return alert("Bir IP adresini süresiz olarak engelleyemezsiniz!");
		}
		if (!blockoptions.reason) {
			return alert('Lütfen engelleme için bir gerekçe belirtin!');
		}

		Morebits.simpleWindow.setButtonsEnabled(false);
		Morebits.status.init(e.target);
		var statusElement = new Morebits.status('Engelleme gerçekleştiriliyor');
		blockoptions.action = 'block';

		blockoptions.user = relevantUserName;

		// boolean-flipped options
		blockoptions.anononly = blockoptions.hardblock ? undefined : true;
		blockoptions.allowusertalk = blockoptions.disabletalk ? undefined : true;

		/*
		  Check if block status changed while processing the form.

		  There's a lot to consider here. list=blocks provides the
		  current block status, but there are at least two issues with
		  relying on it. First, the id doesn't update on a reblock,
		  meaning the individual parameters need to be compared. This
		  can be done roughly with JSON.stringify - we can thankfully
		  rely on order from the server, although sorting would be
		  fine if not - but falsey values are problematic and is
		  non-ideal. More importantly, list=blocks won't indicate if a
		  non-blocked user is blocked then unblocked. This should be
		  exceedingy rare, but regardless, we thus need to check
		  list=logevents, which has a nicely updating logid
		  parameter. We can't rely just on that, though, since it
		  doesn't account for blocks that have expired on their own.

		  As such, we use both. Using some ternaries, the logid
		  variables are false if there's no logevents, so if they
		  aren't equal we defintely have a changed entry (send
		  confirmation). If they are equal, then either the user was
		  never blocked (the block statuses will be equal, no
		  confirmation) or there's no new block, in which case either
		  a block expired (different statuses, confirmation) or the
		  same block is still active (same status, no confirmation).
		*/
		var query = {
			format: 'json',
			action: 'query',
			list: 'blocks|logevents',
			letype: 'block',
			lelimit: 1,
			letitle: 'User:' + blockoptions.user
		};
		// bkusers doesn't catch single IPs blocked as part of a range block
		if (mw.util.isIPAddress(blockoptions.user, true)) {
			query.bkip = blockoptions.user;
		} else {
			query.bkusers = blockoptions.user;
		}
		api.get(query).then(function(data) {
			var block = data.query.blocks[0];
			// As with the initial data fetch, if an IP is blocked
			// *and* rangeblocked, this would only grab whichever
			// block is more recent, which would likely mean a
			// mismatch.  However, if the rangeblock is updated
			// while filling out the form, this won't detect that,
			// but that's probably fine.
			if (data.query.blocks.length > 1 && block.user !== relevantUserName) {
				block = data.query.blocks[1];
			}
			var logevents = data.query.logevents[0];
			var logid = data.query.logevents.length ? logevents.logid : false;

			if (logid !== Twinkle.block.blockLogId || !!block !== !!Twinkle.block.currentBlockInfo) {
				var message = blockoptions.user + ' kullanıcısının engel durumu değiştirildi. ';
				if (block) {
					message += 'Yeni durum: ';
				} else {
					message += 'Son giriş: ';
				}

				var logExpiry = '';
				if (logevents.params.duration) {
					if (logevents.params.duration === 'infinity') {
						logExpiry = 'indefinitely';
					} else {
						var expiryDate = new Morebits.date(logevents.params.expiry);
						logExpiry += (expiryDate.isBefore(new Date()) ? ', bitiş ' : ' until ') + expiryDate.calendar();
					}
				} else { // no duration, action=unblock, just show timestamp
					logExpiry = ' ' + new Morebits.date(logevents.timestamp).calendar();
				}
				message += Morebits.string.toUpperCaseFirstChar(logevents.action) + 'ed by ' + logevents.user + logExpiry +
					' for "' + logevents.comment + '". Ayarlarınızı geçersiz kılmak ister misiniz?';

				if (!confirm(message)) {
					Morebits.status.info('Engelleme gerçekleştiriliyor', 'Kullanıcı tarafından iptal edildi');
					return;
				}
				blockoptions.reblock = 1; // Writing over a block will fail otherwise
			}

			// execute block
			blockoptions.tags = Twinkle.changeTags;
			blockoptions.token = mw.user.tokens.get('csrfToken');
			var mbApi = new Morebits.wiki.api('Engelleme gerçekleştiriliyor', blockoptions, function() {
				statusElement.info('tamamlandı');
				if (toWarn) {
					Twinkle.block.callback.issue_template(templateoptions);
				}
			});
			mbApi.post();
		});
	} else if (toWarn) {
		Morebits.simpleWindow.setButtonsEnabled(false);

		Morebits.status.init(e.target);
		Twinkle.block.callback.issue_template(templateoptions);
	} else {
		return alert('Lütfen Twinkle\'a yapacak bir şey söyleyin!');
	}
};

Twinkle.block.callback.issue_template = function twinkleblockCallbackIssueTemplate(formData) {
	// Use wgRelevantUserName to ensure the block template goes to a single IP and not to the
	// "talk page" of an IP range (which does not exist)
	var userTalkPage = 'Kullanıcı_mesaj:' + mw.config.get('wgRelevantUserName');

	var params = $.extend(formData, {
		messageData: Twinkle.block.blockPresetsInfo[formData.template],
		reason: Twinkle.block.field_template_options.block_reason,
		disabletalk: Twinkle.block.field_template_options.notalk,
		noemail: Twinkle.block.field_template_options.noemail_template,
		nocreate: Twinkle.block.field_template_options.nocreate_template
	});

	Morebits.wiki.actionCompleted.redirect = userTalkPage;
	Morebits.wiki.actionCompleted.notice = 'İşlemler tamamlandı, birkaç saniye içinde kullanıcı mesaj sayfası yüklenecek';

	var wikipedia_page = new Morebits.wiki.page(userTalkPage, 'Kullanıcı mesaj sayfası değişikliği');
	wikipedia_page.setCallbackParameters(params);
	wikipedia_page.load(Twinkle.block.callback.main);
};

Twinkle.block.callback.getBlockNoticeWikitext = function(params) {
	var text = '{{', settings = Twinkle.block.blockPresetsInfo[params.template];
	if (!settings.nonstandard) {
		text += 'subst:' + params.template;
		if (params.article && settings.pageParam) {
			text += '|page=' + params.article;
		}
		
		if (params.dstopic) {
			text += '|topic=' + params.dstopic;
		}
		
		if (!/te?mp|^\s*$|min/.exec(params.expiry)) {
			if (params.indefinite) {
				text += '|indef=evet';
			} else if (!params.blank_duration && !new Morebits.date(params.expiry).isValid()) {
				var süre = params.expiry //Şablondaki süre değeri
					.replace('seconds', 'saniye')
					.replace('second', 'saniye')
					.replace('minutes', 'dakika')
					.replace('minute', 'dakika')
					.replace('hours', 'saat')
					.replace('hour', 'saat')
					.replace('weeks', 'hafta')
					.replace('week', 'hafta')
					.replace('months', 'ay')
					.replace('month', 'ay')
					.replace('years', 'yıl')
					.replace('year', 'yıl')
					.replace('min', 'dakika')
					.replace('sec', 'saniye');
				text += '|süre=' + süre;
			}
		}

		if (!Twinkle.block.isRegistered && !params.hardblock) {
			text += '|anon=evet';
		}

		if (params.reason) {
			text += '|reason=' + params.reason;
		}
		if (params.disabletalk) {
			text += '|notalk=evet';
		}

		// Currently, all partial block templates are "standard"
		// Building the template, however, takes a fair bit of logic
		if (params.partial) {
			if (params.pagerestrictions.length || params.namespacerestrictions.length) {
				var makeSentence = function (array) {
					if (array.length < 3) {
						return array.join(' ve ');
					}
					var last = array.pop();
					return array.join(', ') + ' ve ' + last;

				};
				text += '|area=' + (params.indefinite ? 'belirli ' : 'belirli ');
				if (params.pagerestrictions.length) {
					text += 'sayfalardan (' + makeSentence(params.pagerestrictions.map(function(p) {
						return '[[:' + p + ']]';
					}));
					text += params.namespacerestrictions.length ? ') ve belirli ' : ')';
				}
				if (params.namespacerestrictions.length) {
					// 1 => Talk, 2 => User, etc.
					var namespaceNames = params.namespacerestrictions.map(function(id) {
						return menuFormattedNamespaces[id];
					});
					text += '[[Vikipedi:Ad alanı|ad alanlarından]] (' + makeSentence(namespaceNames) + ')';
				}
			} else if (params.area) {
				text += '|area=' + params.area;
			} else {
				if (params.noemail) {
					text += '|email=evet';
				}
				if (params.nocreate) {
					text += '|accountcreate=evet';
				}
			}
		}
	} else {
		text += params.template;
	}

	if (settings.sig) {
		text += '|sig=' + settings.sig;
	}
	return text + '}}';
};

Twinkle.block.callback.main = function twinkleblockcallbackMain(pageobj) {
	var params = pageobj.getCallbackParameters(),
		date = new Morebits.date(pageobj.getLoadTime()),
		messageData = params.messageData,
		text;

	params.indefinite = Morebits.string.isInfinity(params.expiry);

	if (Twinkle.getPref('blankTalkpageOnIndefBlock') && params.template !== 'uw-lblock' && params.indefinite) {
		Morebits.status.info('Bilgilendirme', 'Tercihlere göre mesaj sayfası boşaltılıyor ve tarih için yeni bir başlık oluşturuluyor');
		text = date.monthHeader() + '\n';
	} else {
		text = pageobj.getPageText();

		var dateHeaderRegex = date.monthHeaderRegex(), dateHeaderRegexLast, dateHeaderRegexResult;
		while ((dateHeaderRegexLast = dateHeaderRegex.exec(text)) !== null) {
			dateHeaderRegexResult = dateHeaderRegexLast;
		}
		// If dateHeaderRegexResult is null then lastHeaderIndex is never checked. If it is not null but
		// \n== is not found, then the date header must be at the very start of the page. lastIndexOf
		// returns -1 in this case, so lastHeaderIndex gets set to 0 as desired.
		var lastHeaderIndex = text.lastIndexOf('\n==') + 1;

		if (text.length > 0) {
			text += '\n\n';
		}

		if (!dateHeaderRegexResult || dateHeaderRegexResult.index !== lastHeaderIndex) {
			Morebits.status.info('Bilgilendirme', 'Bu ay için başlık bulunamadığı için yeni bir başlık oluşturuluyor');
			text += date.monthHeader() + '\n';
		}
	}

	params.expiry = typeof params.template_expiry !== 'undefined' ? params.template_expiry : params.expiry;

	text += Twinkle.block.callback.getBlockNoticeWikitext(params);

	// build the edit summary
	var summary = messageData.summary;
	if (messageData.suppressArticleInSummary !== true && params.article) {
		summary = '[[:' + params.article + ']] sayfasında ' + summary;
	}

	pageobj.setPageText(text);
	pageobj.setEditSummary(summary);
	pageobj.setChangeTags(Twinkle.changeTags);
	pageobj.setWatchlist(Twinkle.getPref('watchWarnings'));
	pageobj.save();
};

Twinkle.addInitCallback(Twinkle.block, 'block');
})(jQuery);


// </nowiki>