Scribd
Upload
32 views12 pages

ExtendedLookupFieldControl Cs

A class that create an extended lookup field control with C# for Sharepoint

Uploaded by

devi das
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
32 views12 pages

ExtendedLookupFieldControl Cs

A class that create an extended lookup field control with C# for Sharepoint

Uploaded by

devi das
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.

26/11/2024 11:14 ExtendedLookupFieldControl.

cs

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

namespace [Link]
{
/// <summary>
/// Control for creating, displaying and editing the <see
cref="T:[Link]"/>
/// field.
/// </summary>
public class ExtendedLookupFieldControl : BaseFieldControl
{
#region Private Members

private const string VS_LISTITEMS = "vs_listitems";


private const string DISPLAY_DELIMITER = "; ";

private Dictionary<int, string> _itemDetails;


private Guid _webSourceId;
private Guid _lookupListId;
private Guid _displayColumnId;
private Guid _valueColumnId;
private bool _allowMultipleItemSelection;
private string _relatedFieldName;
private bool _isRequired;
private static string lookupfieldtext;

private DropDownList ddlLookupItems;


private Literal ltlDisplayItems;
private GroupedItemPicker gipLookupItems;

private ExtendedLookupData _lookupData;

private bool _isInitialised;

#endregion Private Members

#region Public Properties

/// <summary>
/// Get the display delimiter to use for displaying multiple values.
/// </summary>
public static string DisplayDelimiter { get { return DISPLAY_DELIMITER; } }

#endregion Public Properties

#region Constructor

public ExtendedLookupFieldControl(ExtendedLookupFieldType extendedLookupFieldType)


{
if (extendedLookupFieldType == null)
throw new ArgumentNullException("extendedLookupFieldType");

_isInitialised = false;
_webSourceId = [Link];
_lookupListId = new Guid([Link]);
_displayColumnId = new Guid([Link]);
_valueColumnId = [Link];
_allowMultipleItemSelection = [Link];
[Link] cloud/[Link] 1/12
26/11/2024 11:14 [Link]
_relatedFieldName = [Link];
_isRequired = [Link];

#endregion Constructor

#region Overridden Methods

public override void Validate()


{
if (_isRequired)
{
ErrorMessage = "You must specify a value for this required field.";

if (_allowMultipleItemSelection)
{
IsValid = gipLookupItems != null && [Link] > 0;
}
else
{
IsValid = ddlLookupItems != null &&
![Link]([Link]);
}
}
else
{
IsValid = true;
}
}

public override object Value


{
get
{
EnsureChildControls();
InitialiseControls();

_lookupData = new ExtendedLookupData();


_lookupData.WebId = _webSourceId;
_lookupData.ListId = _lookupListId;
_lookupData.DisplayId = _displayColumnId;
_lookupData.ValueId = _valueColumnId;

if (_allowMultipleItemSelection)
{
SPFieldLookupValueCollection lookupValues = GetMultipleItemSelectionValues();
AddLookupValuesToLookupData(lookupValues);
return lookupValues;
}

SPFieldLookupValue lookupValue = GetSingleItemSelectionValue();


if (lookupValue != null)
{
AddLookupValueToLookupData(lookupValue);
}
string data = Serialization<ExtendedLookupData>.SerializeObject(_lookupData);
lookupfieldtext = data;

return lookupValue;

}
set
{
}
}

protected override void OnInit(EventArgs e)


{

[Link] cloud/[Link] 2/12


26/11/2024 11:14 [Link]
[Link](e);

EnsureChildControls();
}

protected override void OnLoad(EventArgs e)


{
[Link](e);

InitialiseControls();
}

protected override void CreateChildControls()


{
if (Field == null) return;

[Link]();

switch (ControlMode)
{
case [Link]:
CreateControlsForDisplay();
break;
case [Link]:
case [Link]:
CreateControlsForNewEdit();
break;
}
}

public override void UpdateFieldValueInItem()


{
[Link]();

if ([Link])
{
IsValid = Value != null;
}

if (_lookupData != null)
{
string data = Serialization<ExtendedLookupData>.SerializeObject(_lookupData);
lookupfieldtext = data;
SPList lookupList = GetLookupList();
List<[Link]> currentValues =
GetSelectedLookupColumns(lookupList, _lookupData, false);
SPFieldUrlValue lien = new SPFieldUrlValue();
[Link] = "test";
[Link] = GetFieldValuesAsLinksAll(_lookupData.WebId, _lookupData.ListId,
_lookupData.ValueId, currentValues);
Item[_relatedFieldName] = lien;

}
}

protected override void RenderFieldForDisplay(HtmlTextWriter output)


{
[Link](output);
}

#endregion Overridden Methods

#region ViewState

protected override void LoadViewState(object savedState)


{
[Link](savedState);

if (ViewState[VS_LISTITEMS] != null)

[Link] cloud/[Link] 3/12


26/11/2024 11:14 [Link]
{
_itemDetails = ViewState[VS_LISTITEMS] as Dictionary<int, string>;
}
}

protected override object SaveViewState()


{
if (_itemDetails != null && _itemDetails.Count > 0)
{
ViewState[VS_LISTITEMS] = _itemDetails;
}

return [Link]();
}

#endregion ViewState

#region Binding

private void BindLookupColumnValues(ListControl listControl,


List<[Link]> columnValues)
{
if (columnValues == null)
return;

[Link] = columnValues;
[Link] = "Display";
[Link] = "Value";
[Link]();
}

private void DropDownList_OnDataBound(object sender, EventArgs e)


{
((DropDownList)sender).[Link](0, new ListItem("(none)", [Link]));
}

#endregion Binding

#region Create Controls

private void CreateControlsForDisplay()


{
ltlDisplayItems = new Literal { ID = "ltlDisplayItems" };
[Link](ltlDisplayItems);
}

private void CreateControlsForNewEdit()


{
if (_allowMultipleItemSelection)
{
CreateMultipleItemSelectionControls();
}
else
{
ddlLookupItems = new DropDownList {ID = "ddlLookupItems"};
if (![Link])
{
[Link] += DropDownList_OnDataBound;
}
[Link](ddlLookupItems);
}
}

private void CreateMultipleItemSelectionControls()


{
const string SEPARATOR_CELL_STYLE = "padding-left: 10px;";
const string CSS_MSLONG = "ms-long";
const string CSS_MSINPUT = "ms-input";
const string CSS_MSBUTTONHEIGHTWIDTH = "ms-ButtonHeightWidth";

[Link] cloud/[Link] 4/12


26/11/2024 11:14 [Link]

gipLookupItems = new GroupedItemPicker


{
ID = "gipLookupItems",
CandidateControlId = "SelectCandidate",
ResultControlId = "SelectResult",
AddButtonId = "btnAdd",
RemoveButtonId = "btnRemove"
};
[Link](gipLookupItems);

Table tblMultipleValue = new Table { ID = "tblMultipleValue", CellPadding = 0,


CellSpacing = 0, CssClass = CSS_MSLONG };

TableRow row = new TableRow();


TableCell cell = new TableCell { CssClass = CSS_MSINPUT };
SPHtmlSelect selectCandidate = new SPHtmlSelect {ID = "SelectCandidate", Width = 143,
Height = 125, Multiple = true };
[Link](selectCandidate);
[Link](cell);
[Link](row);

cell = new TableCell();


[Link]("style", SEPARATOR_CELL_STYLE);
[Link](cell);
[Link](row);

cell = new TableCell { CssClass = CSS_MSINPUT, HorizontalAlign =


[Link], VerticalAlign = [Link] };
HtmlButton btnAdd = new HtmlButton { ID = "btnAdd", InnerText = "Add" };
[Link]("class", CSS_MSBUTTONHEIGHTWIDTH);
[Link](btnAdd);
Literal litBreak = new Literal();
[Link] = "<br /><br />";
[Link](litBreak);
HtmlButton btnRemove = new HtmlButton { ID = "btnRemove", InnerText = "Remove" };
[Link]("class", CSS_MSBUTTONHEIGHTWIDTH);
[Link](btnRemove);
[Link](cell);
[Link](row);

cell = new TableCell();


[Link]("style", SEPARATOR_CELL_STYLE);
[Link](cell);
[Link](row);

cell = new TableCell { CssClass = CSS_MSINPUT };


SPHtmlSelect selectResult = new SPHtmlSelect { ID = "SelectResult", Width = 143,
Height = 125, Multiple = true };
[Link](selectResult);
[Link](cell);
[Link](row);

[Link](tblMultipleValue);
}

#endregion Create Controls

#region Initialise Display

private void InitialiseForDisplay()


{
[Link] = [Link];

SPList lookupList = GetLookupList();


List<[Link]> currentValues =
GetSelectedLookupColumns(lookupList, _lookupData, false);

if (currentValues != null && [Link] > 0)

[Link] cloud/[Link] 5/12


26/11/2024 11:14 [Link]
{
string displayLinks = GetFieldValuesAsLinks(_lookupData.WebId, _lookupData.ListId,
_lookupData.ValueId, currentValues);

if ([Link](displayLinks))
{
foreach ([Link] value in currentValues)
{
[Link] += [Link] + DisplayDelimiter;
}

[Link] = [Link](0,
[Link] - [Link]);
}
else
{
[Link] = displayLinks;
}
}
}

#endregion Initialise Display

#region Initialise New and Edit

private void InitialiseForNewEdit()


{
if (_allowMultipleItemSelection)
{
InitialiseMultipleItemSelectionControls();
}
else
{
if (![Link])
{
SPList lookupList = GetLookupList();
if (lookupList != null)
{
List<[Link]> values =
[Link](lookupList, _displayColumnId, _valueColumnId);

BindLookupColumnValues(ddlLookupItems, values);

if ([Link] > 0)
{
if (IsEditModeValid(_lookupData, [Link]))
{
List<[Link]> selectedValues =
GetSelectedLookupColumns(lookupList, _lookupData);
ListItem currentItem = null;
if ([Link] > 0)
{
// Select the first item in the selectedValues list, this may
happen if the field was configured for multiple items
// and was then changed to a single selection.
currentItem =
[Link](selectedValues[0].[Link]());
}
[Link] = (currentItem != null) ?
[Link](currentItem) : 0;
}
else // Not edit mode, so select the first item in the list
{
[Link] = 0;
}
}
}
}
}

[Link] cloud/[Link] 6/12


26/11/2024 11:14 [Link]
}

private void InitialiseMultipleItemSelectionControls()


{
if ([Link])
return;

SPList lookupList = GetLookupList();


if (lookupList != null)
{
List<[Link]> values =
[Link](lookupList, _displayColumnId, _valueColumnId);

_itemDetails = new Dictionary<int, string>();


foreach ([Link] value in values)
{
_itemDetails.Add(Convert.ToInt32([Link]), [Link]);
}

if (IsEditModeValid(_lookupData, [Link]))
{
List<[Link]> selectionValues =
GetSelectedLookupColumns(lookupList, _lookupData);

foreach ([Link] value in selectionValues)


{
[Link]([Link](), [Link]);
}

UpdateCandidateColumns(values, selectionValues);
}

foreach ([Link] value in values)


{
[Link]([Link](), [Link], [Link],
[Link]);
}
}
}

#endregion Initialise New and Edit

#region Private Methods

private void AddLookupValuesToLookupData(SPFieldLookupValueCollection lookupValues)


{
foreach (SPFieldLookupValue lookupValue in lookupValues)
{
AddLookupValueToLookupData(lookupValue);
}
}

private void AddLookupValueToLookupData(SPFieldLookupValue lookupValue)


{
_lookupData.[Link]([Link], [Link]);
}

private SPList GetLookupList()


{
SPList lookupList;
using (SPWeb web = [Link](_webSourceId))
{
lookupList = (from list in [Link]<SPList>()
where [Link](_lookupListId)
select list).SingleOrDefault();
}

return lookupList;
}

[Link] cloud/[Link] 7/12


26/11/2024 11:14 [Link]

private void InitialiseControls()


{
if (_isInitialised)
return;

string data = lookupfieldtext == null


? [Link]
: lookupfieldtext;

_lookupData = ![Link](data) ?
Serialization<ExtendedLookupData>.DeserializeObject(data) : new ExtendedLookupData();

switch (ControlMode)
{

case [Link]:
InitialiseForDisplay();
break;
case [Link]:
case [Link]:
InitialiseForNewEdit();
break;
}

_isInitialised = true;
}

private void UpdateCandidateColumns(List<[Link]>


candidate, List<[Link]> selection)
{
if ([Link] > 0 && [Link] > 0)
{
foreach ([Link] item in selection)
{
var candidateItem = (from i in candidate
where [Link] == [Link] && DoesEqual([Link],
[Link])
select i).FirstOrDefault();

if (candidateItem != null)
{
[Link](candidateItem);
}
}
}
}

private bool DoesEqual(object candidate, object selection)


{
int candidateInt;
if ([Link]([Link](), out candidateInt))
{
int selectionInt;
if ([Link]([Link](), out selectionInt))
{
return candidateInt == selectionInt;
}
}
else
{
double candidateDouble;
if ([Link]([Link](), out candidateDouble))
{
double selectionDouble;
if ([Link]([Link](), out selectionDouble))
{
return [Link](selectionDouble);
}

[Link] cloud/[Link] 8/12


26/11/2024 11:14 [Link]
}
}

return false;
}

private List<[Link]> GetSelectedLookupColumns(SPList


lookupList, ExtendedLookupData lookupData)
{
return GetSelectedLookupColumns(lookupList, lookupData, true);
}

private List<[Link]> GetSelectedLookupColumns(SPList


lookupList, ExtendedLookupData lookupData, bool removeInvalidEntries)
{
List<[Link]> columns = new
List<[Link]>();

if (lookupData != null && [Link] != null &&


[Link] > 0)
{
foreach (KeyValuePair<int, string> value in [Link])
{
string currentDisplayValue = null;
if (lookupList != null)
{
currentDisplayValue = (from item in [Link]<SPListItem>()
where DoesEqual(item[_valueColumnId], [Link])
select [Link]).FirstOrDefault();
}

if ([Link](currentDisplayValue) && !removeInvalidEntries)


{
currentDisplayValue = [Link];
}

if (![Link](currentDisplayValue))
{
[Link](new [Link] { Value =
[Link], Display = currentDisplayValue });
}
}
}

return columns;
}

private SPFieldLookupValueCollection GetMultipleItemSelectionValues()


{
SPFieldLookupValueCollection lookupValues = new SPFieldLookupValueCollection();

if ([Link] == null || [Link] > 0)


{
// From all available items, filter by the selected item ids.
[Link](from KeyValuePair<int, string> kvp in _itemDetails
where (
from gip in
[Link]<string>()
where Convert.ToInt32(gip) == [Link]
select gip
).Contains([Link]())
select new SPFieldLookupValue([Link], [Link]));
}

return lookupValues;
}

private SPFieldLookupValue GetSingleItemSelectionValue()


{

[Link] cloud/[Link] 9/12


26/11/2024 11:14 [Link]
SPFieldLookupValue lookupValue = null;

if (ddlLookupItems != null &&


![Link]([Link]))
{
lookupValue = new
SPFieldLookupValue(Convert.ToInt32([Link]),
[Link]);
}

return lookupValue;
}

/// <summary>
/// If lookup list or value column Id has changed since the last time this field's value
was saved, the selected values are no longer valid,
/// so the edit mode is invalidated.
/// </summary>
/// <param name="lookupData">ExtendedLookupData object of the current fields saved values.
</param>
/// <param name="lookupListId">The id of the lookup list.</param>
/// <returns>If edit mode is valid.</returns>
private bool IsEditModeValid(ExtendedLookupData lookupData, Guid lookupListId)
{
return (ControlMode == [Link] && lookupListId == [Link] &&
_valueColumnId == [Link]);
}

private string GetFieldValuesAsLinks(Guid webId, Guid listId, Guid valueColumnId,


List<[Link]> values)
{
if (values == null || [Link] == 0)
return [Link];

string displayFormUrl;
Dictionary<int, bool> itemExists = new Dictionary<int, bool>();

using ([Link] scope = new


[Link]())
{
try
{
using (SPWeb web = [Link](webId))
{
SPList lookupList = (from list in [Link]<SPList>()
where [Link](listId)
select list).SingleOrDefault();

if (lookupList != null && [Link](valueColumnId))


{
foreach ([Link] value in values)
{
int itemId = Convert.ToInt32([Link]);
SPListItem listItem = (from item in
[Link]<SPListItem>()
where [Link] == itemId
select item).SingleOrDefault();

[Link](itemId, listItem != null);


}
}

displayFormUrl = lookupList == null ? null :


[Link]([Link], "/_layouts/[Link]?PageType=4&ListId=",
[Link]("B"));
}
}
catch (UnauthorizedAccessException)
{

[Link] cloud/[Link] 10/12


26/11/2024 11:14 [Link]
displayFormUrl = null;
}
}
if ([Link](displayFormUrl))
{
return null;
}

StringBuilder sb = new StringBuilder();

for (int ii = 0; ii < [Link]; ii++)


{
if (ii > 0)
{
[Link](DisplayDelimiter);
}

int itemId = Convert.ToInt32(values[ii].Value);


if (itemExists[itemId])
{
StringBuilder innerBuilder = new StringBuilder();
[Link](displayFormUrl);
[Link]("&ID=");
[Link](values[ii].[Link]());
[Link]("&RootFolder=*");
[Link]("<a ");
[Link]("href=\"");
[Link](innerBuilder);
[Link]("\">");
[Link]([Link](values[ii].Display));
[Link]("</a>");
}
else
{
[Link]([Link](values[ii].Display));
}
}

return [Link]();
}
private string GetFieldValuesAsLinksAll(Guid webId, Guid listId, Guid valueColumnId,
List<[Link]> values)
{
if (values == null || [Link] == 0)
return [Link];

string displayFormUrl;
Dictionary<int, bool> itemExists = new Dictionary<int, bool>();

using ([Link] scope = new


[Link]())
{
try
{
using (SPWeb web = [Link](webId))
{
SPList lookupList = (from list in [Link]<SPList>()
where [Link](listId)
select list).SingleOrDefault();

if (lookupList != null && [Link](valueColumnId))


{
foreach ([Link] value in values)
{
int itemId = Convert.ToInt32([Link]);
SPListItem listItem = (from item in
[Link]<SPListItem>()
where [Link] == itemId
select item).SingleOrDefault();

[Link] cloud/[Link] 11/12


26/11/2024 11:14 [Link]

[Link](itemId, listItem != null);


}
}

displayFormUrl = lookupList == null ? null :


[Link]([Link], "/_layouts/[Link]?PageType=4&ListId=",
[Link]("B"));
}
}
catch (UnauthorizedAccessException)
{
displayFormUrl = null;
}
}
if ([Link](displayFormUrl))
{
return null;
}

StringBuilder sb = new StringBuilder();


String result = "";
for (int ii = 0; ii < [Link]; ii++)
{
if (ii > 0)
{
[Link](DisplayDelimiter);
}

int itemId = Convert.ToInt32(values[ii].Value);


if (itemExists[itemId])
{
StringBuilder innerBuilder = new StringBuilder();
[Link](displayFormUrl);
[Link]("&ID=");
[Link](values[ii].[Link]());
[Link]("&RootFolder=*");
[Link]("<a ");
[Link]("href=\"");
[Link](innerBuilder);
[Link]("\">");
[Link]([Link](values[ii].Display));
[Link]("</a>");
result = [Link]();
}
else
{
[Link]([Link](values[ii].Display));
}
}

return result;
}

#endregion Private Methods


}
}

[Link] cloud/[Link] 12/12

You might also like