public static bool SafeCheckboxValue(this Item item, ID fieldId)
{
var toReturn = false;
if (item != null && !fieldId.IsNull)
{
CheckboxField checkboxField = item.Fields[fieldId];
if (checkboxField != null)
{
toReturn = checkboxField.Checked;
}
}
else
{
if (item == null)
{
GatedContentLogger.Error("item is null", new object());
}
if (fieldId.IsNull)
{
GatedContentLogger.Error("fieldId is null", new object());
}
}
return(toReturn);
}
protected void rptNav_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
try
{
Item nodeItm = (Item)e.Item.DataItem;
CheckboxField showInNavigation = nodeItm.Fields["Show in Navigation"];
var isChecked = showInNavigation.Checked;
if (isChecked)
{
HyperLink fldNavLink = (HyperLink)e.Item.FindControl("fldNavLink");
fldNavLink.NavigateUrl = Sitecore.Links.LinkManager.GetItemUrl(nodeItm);
Text fldNavTitle = (Text)e.Item.FindControl("fldNavTitle");
fldNavTitle.Item = nodeItm;
}
else
{
e.Item.Visible = false;
}
}
catch (Exception ex)
{
}
}
}
public override void Execute(CommandContext context)
{
try
{
Database dbweb = Database.GetDatabase(CTConfiguration.SitecoreMasterDatabase);
Item configurationitem = dbweb.GetItem(new ID(CTConfiguration.ItemId));
CheckboxField __enableCT = configurationitem.Fields[CTConfiguration.EnableCT];
if (__enableCT.Checked)
{
Assert.ArgumentNotNull(context, "context");
if (context.Items.Length == 1)
{
NameValueCollection parameters = new NameValueCollection();
parameters["items"] = base.SerializeItems(context.Items);
parameters.Add(context.Parameters);
Context.ClientPage.Start(this, "Run", parameters);
}
}
}
catch (Exception ex)
{
Log.Error("ContentTranslate -Execute - " + ex.Message, typeof(ContentTranslate));
}
}
protected virtual string GenerateHeaders()
{
const string preloadKeyword = "preload";
const string includeSubDomainsKeyWord = "includeSubDomains";
var settings = _securityHeadersSiteContext.GetSettingItem(Templates.HttpStrictTransportPolicy.Id);
if (settings == null)
{
return(string.Empty);
}
var maxAge = settings[Templates.HttpStrictTransportPolicy.Fields.MaxAge];
CheckboxField includeSubDomains = settings.Fields[Templates.HttpStrictTransportPolicy.Fields.IncludeSubDomains];
CheckboxField preload = settings.Fields[Templates.HttpStrictTransportPolicy.Fields.IncludeSubDomains];
var header = new StringBuilder();
if (!string.IsNullOrWhiteSpace(maxAge))
{
header.Append($"max-age={maxAge}; ");
}
if (includeSubDomains.Checked)
{
header.Append($"{includeSubDomainsKeyWord}; ");
}
if (preload.Checked)
{
header.Append(preloadKeyword);
}
return(header.ToString().Trim());
}
public override CommandState QueryState(CommandContext context)
{
Database dbweb = Database.GetDatabase(CTConfiguration.SitecoreMasterDatabase);
Item configurationitem = dbweb.GetItem(new ID(CTConfiguration.ItemId));
CheckboxField __enableCT = configurationitem.Fields[CTConfiguration.EnableCT];
if (__enableCT.Checked)
{
Error.AssertObject((object)context, "context");
if (context.Items.Length == 0)
{
return(CommandState.Disabled);
}
if (!context.Items[0].Paths.IsContentItem)
{
return(CommandState.Disabled);
}
if (context.Items[0].Locking.IsLocked())
{
return(CommandState.Disabled);
}
if (context.Items[0].Language.CultureInfo.TwoLetterISOLanguageName == "en")
{
return(CommandState.Disabled);
}
return(base.QueryState(context));
}
return(CommandState.Hidden);
}
public PageSitemapSettings(Item item)
{
if (item.HasField(Templates.PageSiteMapSettings.Fields.ChangeFrequency))
{
this.ChangeFrequency = item.Fields[Templates.PageSiteMapSettings.Fields.ChangeFrequency].Value;
}
if (item.HasField(Templates.PageSiteMapSettings.Fields.Priority))
{
this.Priority = item.Fields[Templates.PageSiteMapSettings.Fields.Priority].Value;
}
if (item.HasField(Templates.PageSiteMapSettings.Fields.OmitFromSitemap))
{
this.OmitFromSitemap = ((CheckboxField)item.Fields[Templates.PageSiteMapSettings.Fields.OmitFromSitemap]).Checked;
}
if (item.HasField(Templates.PageVideoSiteMapSettings.Fields.HasVideo))
{
CheckboxField chkbx = (CheckboxField)item.Fields[Templates.PageVideoSiteMapSettings.Fields.HasVideo];
if (chkbx.Checked)
{
this.Video = new VideoSiteMapData(item);
}
}
this.Images = new List <ImageSiteMapData>();
if (item.HasField(Templates.PageSiteMapSettings.Fields.Images))
{
var multiFld = (MultilistField)item.Fields[Templates.PageSiteMapSettings.Fields.Images];
foreach (var imgItm in multiFld.GetItems())
{
this.Images.Add(new ImageSiteMapData(imgItm));
}
}
}
public MapPluginViewModel GetModel()
{
// Instantiate Map Model.
MapPluginViewModel model = new MapPluginViewModel();
// Current Rendering Item.
var contentItem = RenderingContext.Current?.Rendering?.Item ?? null;
model.Item = contentItem;
if (contentItem == null)
{
return(model);
}
// Get Bing Maps API Key.
model.ApiKey = GetBingMapsApiKey();
// Set Property Values.
CheckboxField disableZoomField = contentItem.Fields[Resources.Resource.scFieldDisableZooming];
model.DisableZooming = disableZoomField == null ? false : disableZoomField.Value == "1";
CheckboxField disableSearchField = contentItem.Fields[Resources.Resource.scFieldDisableSearch];
model.DisableSearch = disableSearchField == null ? false : disableSearchField.Value == "1";
ReferenceField mapTypeField = contentItem.Fields[Resources.Resource.scFieldType];
model.MapTypeId = (mapTypeField == null || String.IsNullOrEmpty(mapTypeField?.TargetItem?.Fields["Value"]?.Value)) ? "Microsoft.Maps.MapTypeId.road" : mapTypeField?.TargetItem?.Fields["Value"]?.Value;
model.Guid = contentItem.ID.Guid.ToString();
return(model);
}
public void Process(GetRenderingDatasourceArgs args)
{
Assert.ArgumentNotNull(args, nameof(args));
CheckboxField datasource = args.RenderingItem.Fields[Templates.RenderingOptions.Fields.SupportsLocalDatasource];
if (datasource == null || !datasource.Checked)
{
return;
}
var contextItem = args.ContentDatabase.GetItem(args.ContextItemPath);
if (contextItem == null)
{
return;
}
var localDatasourceFolder = GetConfiguredLocalDatasourceFolder(contextItem, args.Prototype);
if (localDatasourceFolder == null)
{
Log.Warn($"Cannot find the local datasource folder template '{Settings.LocalDatasourceFolderTemplate}'", this);
return;
}
//Add the datasource folder to the top of the list to make it appear first in the dialog
args.DatasourceRoots.Insert(0, localDatasourceFolder);
}
public IEnumerable <MVPCategory> GetMVPCategories()
{
//to do: it should be cached
Item FolderItem = Sitecore.Context.Database.GetItem(Constants.MVPCategory.Folder.FOLDER_ID);
if (FolderItem == null)
{
yield break;
}
foreach (Item mvpCategory in FolderItem.Children)
{
CheckboxField ck = mvpCategory.Fields[Constants.MVPCategory.Template.Fields.ACTIVE];
var mvpCategoryModel = new MVPCategory
{
ID = mvpCategory.ID.Guid,
Name = mvpCategory.Fields[Constants.MVPCategory.Template.Fields.NAME].Value,
Active = ck?.Checked ?? false,
};
if (string.IsNullOrWhiteSpace(mvpCategoryModel.Name))
{
mvpCategoryModel.Name = mvpCategory.Name;
}
yield return(mvpCategoryModel);
}
}
public string RetrieveDestination(Item processor, string rootDestination, string source, Uri mediaSource, Uri baseUri)
{
CheckboxField keepHeirarchy = (CheckboxField)processor.Fields["Keep Folder Heirarchy"];
string finalDestination;
string cleanSource = source;
if (cleanSource.Contains("?"))
{
cleanSource = cleanSource.Remove(cleanSource.IndexOf('?'));
}
if (keepHeirarchy.Checked)
{
if (mediaSource.Host == baseUri.Host)
{
finalDestination = string.Concat(rootDestination, Path.GetDirectoryName(cleanSource), "/").Replace("%20", "-");
}
else
{
finalDestination = string.Concat(rootDestination, Path.GetDirectoryName(mediaSource.PathAndQuery), "/").Replace("%20", "-");
}
}
else
{
finalDestination = rootDestination + "/";
}
return(finalDestination.Replace("\\", "/").Replace("//", "/").Replace("/-/media/", "/"));
}
public void Load(Item item)
{
var db = item.Database;
this.ConfigItem = item;
if (item != null)
{
this.SiteConfigurationId = item.ID.Guid;
}
if (item.HasField("White Listing Enabled"))
{
CheckboxField field = (CheckboxField)item.Fields["White Listing Enabled"];
this.WhiteListingEnabled = field.Checked;
}
this.RestrictedAccessPageId = Guid.Empty;
if (item.HasField("Restricted Access Page") && !string.IsNullOrEmpty(item.Fields["Restricted Access Page"].Value))
{
try
{
this.RestrictedAccessPageId = new Guid(item.Fields["Restricted Access Page"].Value);
}
catch { }
}
}
public MediaProcessor(Item processor)
{
MediaTypes = RetrieveMediaTypes(processor);
var root = processor.Fields["Root Destination"].Value;
RootDestination = processor.Database.GetItem(root).Paths.Path;
CheckboxField importExternalMediaCheck = (CheckboxField)processor.Fields["Import External Media URLs"];
}
public bool FiletrItem(Item currentitem)
{
LinkField link = currentitem.Fields["Destination"];
var item = Sitecore.Context.Database.GetItem(link.TargetID);
CheckboxField field = (CheckboxField)item.Fields["Include In Navigation"];
return(field.Checked);
}
private bool Is_Included(Item currentitem)
{
Sitecore.Data.Fields.LinkField link = currentitem.Fields["Destination"];
var item = Sitecore.Context.Database.GetItem(link.TargetID);
CheckboxField field = (CheckboxField)item.Fields["IncludeInNavigation"];
return(field.Checked);
}
/// <summary>
/// Converts from.
/// </summary>
/// <param name="storage">The storage.</param>
/// <returns>
/// The from.
/// </returns>
public override bool ConvertFrom([NotNull] Field storage)
{
Assert.ArgumentNotNull(storage, "storage");
CheckboxField cb = new CheckboxField(storage);
return(cb.Checked);
}
public override Field ToStorage(bool entityMember)
{
CheckboxField cb = new CheckboxField(this.StorageObject)
{
Checked = entityMember
};
return(cb.InnerField);
}
private static AreaRouteData GetAreaRouteDataFromRenderingItem(RenderingItem renderingItem)
{
var fields = renderingItem.InnerItem.Fields;
var action = fields[Constants.Fields.Controller.Action].GetValue(true);
var controller = fields[Constants.Fields.Controller.Name].GetValue(true);
var area = fields[Constants.Fields.Controller.Area].GetValue(true);
var useChildActionBehavior = new CheckboxField(fields[Constants.Fields.Controller.UseChildActionBehavior]).Checked;
return new AreaRouteData(controller, action, area, useChildActionBehavior);
}
public static bool Checked(Item item, string field)
{
CheckboxField cb = item.Fields[field];
if (cb != null)
{
return(cb.Checked);
}
return(false);
}
private static AreaRouteData GetAreaRouteDataFromRenderingItem(RenderingItem renderingItem)
{
var fields = renderingItem.InnerItem.Fields;
var action = fields[Constants.Fields.Controller.Action].GetValue(true);
var controller = fields[Constants.Fields.Controller.Name].GetValue(true);
var area = fields[Constants.Fields.Controller.Area].GetValue(true);
var useChildActionBehavior = new CheckboxField(fields[Constants.Fields.Controller.UseChildActionBehavior]).Checked;
return(new AreaRouteData(controller, action, area, useChildActionBehavior));
}
public void Process(Item[] items, Sitecore.Tasks.CommandItem commandItem, ScheduleItem schedule)
{
CheckboxField active = commandItem.InnerItem.Fields["active"];
if (active.Checked)
{
//prepare email message
string from = commandItem["from"];
string to = commandItem["to"];
string subject = commandItem["subject"];
MailMessage message = new MailMessage(from, to)
{
Subject = subject,
};
//attach reports in excel format
MultilistField reportReferences = commandItem.InnerItem.Fields["reports"];
foreach (Item item in reportReferences.GetItems())
{
ReportItem reportItem = null;
Report report = null;
try
{
reportItem = new ReportItem(item);
report = new Report();
foreach (var sItem in reportItem.Scanners)
{
report.AddScanner(sItem);
}
foreach (var vItem in reportItem.Viewers)
{
report.AddViewer(vItem);
}
foreach (var fItem in reportItem.Filters)
{
report.AddFilter(fItem);
}
report.Run();
//attach to mail message
string tempPath = new ASR.Export.HtmlExport(report, reportItem).SaveFile("Automated report " + reportItem.Name, "xls");
Attachment newAttachment = new Attachment(tempPath);
message.Attachments.Add(newAttachment);
}
catch (Exception ex)
{
message.Body += String.Format("An error occured while running '{0}'\n{1}\n\n", reportItem.Name, ex.ToString());
}
}
MainUtil.SendMail(message);
}
}
/// <summary>
/// Sets Checkbox field
/// </summary>
/// <param name="newItem"></param>
/// <param name="sitecoreFieldName"></param>
public void SetCheckboxField(BaseItem newItem, string sitecoreFieldName)
{
CheckboxField checkboxField = newItem.Fields[sitecoreFieldName];
if (checkboxField == null)
{
return;
}
checkboxField.Checked = true;
}
private void Page_Load(object sender, EventArgs e)
{
CheckboxField allowPrint = Sitecore.Context.Item.Fields["Allow Print"];
if (allowPrint != null)
{
if (allowPrint.Checked)
{
phPrint.Visible = true;
}
}
}
/// <summary>
/// The page <head /> element.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
CheckboxField responsive = ItemReferences.SiteRoot.Fields["Enable Responsive"];
if (responsive != null)
{
if (responsive.Checked)
{
ResponsiveDesign.Visible = true;
}
}
}
public Design(Item item)
{
if (item.HasField(Templates.Design.Fields.Styles))
{
MultilistField field = (MultilistField)item.Fields[Templates.Design.Fields.Styles];
if (field.TargetIDs.Length > 0)
{
this.Styles = new List <Resource>();
foreach (var id in field.TargetIDs)
{
var resourceItem = Sitecore.Context.Database.Items[id];
// in case referenced item was deleted and warning dialog ignored, causing broken link
if (resourceItem != null)
{
this.Styles.Add(new Resource(resourceItem));
}
else
{
Sitecore.Diagnostics.Log.Warn("Styles item " + id.ToString() + " not found in database, skipping", this);
}
}
}
}
if (item.HasField(Templates.Design.Fields.Scripts))
{
MultilistField field = (MultilistField)item.Fields[Templates.Design.Fields.Scripts];
if (field.TargetIDs.Length > 0)
{
this.Scripts = new List <Resource>();
foreach (var id in field.TargetIDs)
{
var resourceItem = Sitecore.Context.Database.Items[id];
// in case referenced item was deleted and warning dialog ignored, causing broken link
if (resourceItem != null)
{
this.Scripts.Add(new Resource(resourceItem));
}
else
{
Sitecore.Diagnostics.Log.Warn("Scripts item " + id.ToString() + " not found in database, skipping", this);
}
}
}
}
if (item.HasField(Templates.Design.Fields.Minify))
{
CheckboxField field = (CheckboxField)item.Fields[Templates.Design.Fields.Minify];
this.Minify = field.Checked;
}
}
private string GenerateHeaders()
{
var settings = _securityHeadersSiteContext.GetSettingItem(Templates.XContentTypeOptions.Id);
if (settings == null)
{
return(string.Empty);
}
CheckboxField enabled = settings.Fields[Templates.XContentTypeOptions.Fields.Enabled];
return(enabled.Checked ? "nosniff" : string.Empty);
}
public void BooleanField_CanImplicitCastToCheckboxField()
{
using (var item = new TestItemContext())
{
item.SetField(TestFields.BOOLEAN, "1");
var field = new BooleanField(new Lazy <Field>(() => item[TestFields.BOOLEAN]), null);
CheckboxField sitecoreField = field;
Assert.IsTrue(sitecoreField.Checked);
}
}
static public bool GetCheckBoxFieldValue(this Item item, ID fieldId)
{
CheckboxField f = (CheckboxField)GetField(item, fieldId);
if (f != null)
{
return(f.Checked);
}
else
{
return(false);
}
}
private string GenerateXssHeaders()
{
var xssSettings = _securityHeadersSiteContext.GetSettingItem(Templates.XssProtection.Id);
if (xssSettings == null)
{
return(string.Empty);
}
CheckboxField enabled = xssSettings.Fields[Templates.XssProtection.Fields.Enabled];
return(enabled.Checked ? "1; mode=block" : string.Empty);
}
private void InitilizeConfig()
{
try
{
Database tempdb = Sitecore.Configuration.Factory.GetDatabase("web"); //don't use Master as this does not exist in CD Server environments
Item configItem = tempdb.GetItem(Constants.Guids.Items.AdvancedSiteMapConfigItemId);
if (configItem == null)
{
throw new Exception("Advanced SiteMap config item was not found.");
}
this.targetDatabaseName = configItem.Fields[ConfigFieldsNames.TargetDatabaseName].Value;
CheckboxField _EnableRefreshXMLONPublish = configItem.Fields[ConfigFieldsNames.EnableRefreshXMLONPublish];
if (_EnableRefreshXMLONPublish != null)
{
this.enableRefreshSiteMapOnPublish = _EnableRefreshXMLONPublish.Checked;
}
CheckboxField _MultilingualSiteMapXML = configItem.Fields[ConfigFieldsNames.MultilingualSiteMapXML];
if (_MultilingualSiteMapXML != null)
{
this.enableRefreshSiteMapOnPublish = _MultilingualSiteMapXML.Checked;
}
CheckboxField _EnableSendXMLToSearchEngines = configItem.Fields[ConfigFieldsNames.EnableSendXMLToSearchEngines];
if (_EnableSendXMLToSearchEngines != null)
{
this.enableSendXMLToSearchEngines = _EnableSendXMLToSearchEngines.Checked;
}
List <Item> _EnabledSearchEngines = configItem.Axes.GetDescendants().Where(p => p.TemplateID == Sitecore.AdvancedSiteMap.Constants.Guids.Templates.SiteMapSearchEngineConfigTemplateId &&
p.Fields[SiteMapSearchEngineFields.Enabled].Value == "1").ToList();
if (_EnabledSearchEngines != null && _EnabledSearchEngines.Any())
{
this.enabledSearchEngines = _EnabledSearchEngines;
}
List <Item> _DefinedSites = configItem.Axes.GetDescendants().Where(p => p.TemplateID == Sitecore.AdvancedSiteMap.Constants.Guids.Templates.SiteMapSiteTemplateId).ToList();
if (_DefinedSites != null && _DefinedSites.Any())
{
this.definedSites = _DefinedSites;
}
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error(ex.Message, "Class : SiteMapConfig");
}
}
public void Field_WhenCalled_InSyncWithCheckboxField(string fieldName, bool isChecked, ID fieldId)
{
// Arrange
var fakeItem = new FakeItem();
fakeItem.Add(fieldId, fieldName, isChecked);
Item item = fakeItem;
// Act
var field = new CheckboxField(item.Fields[fieldId]);
// Assert
field.Checked.Should().Be(isChecked);
}
public static bool IsChecked(this Item datasource, string fieldName)
{
bool check = false;
if (datasource != null)
{
Field field = datasource.Fields[fieldName];
if (field != null)
{
CheckboxField checkbox = (CheckboxField)field;
check = checkbox != null && checkbox.Checked;
}
}
return(check);
}
/// <summary>
/// Converts the field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="writer">The writer.</param>
private static void ConvertField(Field field, XmlTextWriter writer)
{
switch (field.Type.ToLower())
{
case "lookup":
LookupField lookupField = new LookupField(field);
if (lookupField.TargetItem != null)
{
string language = lookupField.TargetItem["Regional Iso Code"];
if (string.IsNullOrEmpty(language) || !UseRegionalIsoCodeForEnglish)
{
language = lookupField.TargetItem["Iso"];
}
if (!string.IsNullOrEmpty(language))
{
writer.WriteStartAttribute(field.Name, string.Empty);
writer.WriteString(language);
writer.WriteEndAttribute();
}
}
break;
case "link":
LinkField link = new LinkField(field);
if (link.InternalPath != string.Empty)
{
writer.WriteStartAttribute(field.Name, string.Empty);
writer.WriteString(link.InternalPath);
writer.WriteEndAttribute();
}
break;
case "checkbox":
CheckboxField checkbox = new CheckboxField(field);
if (field.Name == "mode")
{
if (!checkbox.Checked)
{
writer.WriteStartAttribute(field.Name, string.Empty);
writer.WriteString("off");
writer.WriteEndAttribute();
}
}
else
{
if (checkbox.Checked)
{
writer.WriteStartAttribute(field.Name, string.Empty);
writer.WriteString("true");
writer.WriteEndAttribute();
}
}
break;
default:
if (field.Value != string.Empty)
{
writer.WriteStartAttribute(field.Name, string.Empty);
writer.WriteString(field.Value);
writer.WriteEndAttribute();
}
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CheckboxProperty"/> class.
/// </summary>
/// <param name="field">The Sitecore field to wrap.</param>
public CheckboxProperty(Field field)
: base(field)
{
this.checkboxField = field;
}
protected IStorageCheckboxField CreateEmptyCheckboxFieldObject(CheckboxField field)
{
var storageService = service.StorageService;
return (IStorageCheckboxField)storageService.GetObjectFactory().CreateEmptyFieldObject(field.GetType());
}
