/// <summary>
/// Display the list of values attached to the current lookup group
/// </summary>
private void UpdateDataView()
{
if (lookupGroupId != -1)
{
LookupValueList lookupValuesList = LookupGroup.GetByKey(lookupGroupId).Values;
dg.DataSource = lookupValuesList;
Utils.InitGridSort(ref dg, false);
dg.DataBind();
Utils.EnableIntelligentSort(ref dg, Convert.ToInt32(txtSortColPos.Value));
dg.DisplayLayout.AllowSortingDefault = AllowSorting.No;
dg.DisplayLayout.CellClickActionDefault = CellClickAction.Edit;
// Refresh tab title
UITools.RefreshTab(Page, "Values", lookupValuesList.Count);
if (dg.Rows.Count == 0)
{
UITools.HideToolBarButton(uwToolbar, "Delete");
UITools.HideToolBarSeparator(uwToolbar, "DeleteSep");
}
else
{
if (SessionState.User.HasCapability(CapabilitiesEnum.MANAGE_DICTIONARY))
{
UITools.ShowToolBarButton(uwToolbar, "Delete");
UITools.ShowToolBarSeparator(uwToolbar, "DeleteSep");
}
}
}
}
public IObservableGroup GetObservableGroup(IGroup group, string collectionName = null)
{
var requiredComponents = ComponentTypeLookup.GetComponentTypes(group.RequiredComponents);
var excludedComponents = ComponentTypeLookup.GetComponentTypes(group.ExcludedComponents);
var lookupGroup = new LookupGroup(requiredComponents, excludedComponents);
var observableGroupToken = new ObservableGroupToken(lookupGroup, collectionName);
if (_observableGroups.ContainsKey(observableGroupToken))
{
return(_observableGroups[observableGroupToken]);
}
var entityMatches = GetEntitiesFor(lookupGroup, collectionName);
var configuration = new ObservableGroupConfiguration
{
ObservableGroupToken = observableGroupToken,
InitialEntities = entityMatches
};
if (collectionName != null)
{
configuration.NotifyingCollection = _collections[collectionName];
}
else
{
configuration.NotifyingCollection = this;
}
var observableGroup = ObservableGroupFactory.Create(configuration);
_observableGroups.Add(observableGroupToken, observableGroup);
return(_observableGroups[observableGroupToken]);
}
// Display data
protected void UpdateDataView()
{
if (lookupGroupId == -1)
{
// *************************************************************************
// Provide an empty screen to create a new Input form
// *************************************************************************
panelId.Visible = false;
Page.DataBind();
UITools.HideToolBarButton(uwToolbar, "Delete");
UITools.HideToolBarSeparator(uwToolbar, "DeleteSep");
}
else
{
LookupGroup lookupObj = LookupGroup.GetByKey(lookupGroupId);
txtGroupId.Text = lookupObj.Id.ToString();
txtGroupName.Text = lookupObj.Name;
txtComment.Text = lookupObj.Comment;
cbMultiChoice.Checked = lookupObj.MultiChoice;
panelId.Visible = true;
Page.DataBind();
}
}
public IObservableGroup GetObservableGroup(IGroup group, params int[] collectionIds)
{
var requiredComponents = ComponentTypeLookup.GetComponentTypes(group.RequiredComponents);
var excludedComponents = ComponentTypeLookup.GetComponentTypes(group.ExcludedComponents);
var lookupGroup = new LookupGroup(requiredComponents, excludedComponents);
var observableGroupToken = new ObservableGroupToken(lookupGroup, collectionIds);
if (_observableGroups.Contains(observableGroupToken))
{
return(_observableGroups[observableGroupToken]);
}
var entityMatches = GetEntitiesFor(lookupGroup, collectionIds);
var configuration = new ObservableGroupConfiguration
{
ObservableGroupToken = observableGroupToken,
InitialEntities = entityMatches
};
if (collectionIds != null && collectionIds.Length > 0)
{
configuration.NotifyingCollections = _collections.Where(x => collectionIds.Contains(x.Id));
}
else
{
configuration.NotifyingCollections = new [] { this };
}
var observableGroup = ObservableGroupFactory.Create(configuration);
_observableGroups.Add(observableGroup);
return(_observableGroups[observableGroupToken]);
}
// Save the new or updated Input form
private void Save()
{
LookupGroup lookupObj = LookupGroup.GetByKey(lookupGroupId);
if (lookupObj == null)
{
lookupObj = new LookupGroup(lookupGroupId, txtGroupName.Text.Trim(), txtComment.Text.Trim(), (bool)cbMultiChoice.Checked);
}
else
{
lookupObj.Name = txtGroupName.Text;
lookupObj.Comment = txtComment.Text;
lookupObj.MultiChoice = cbMultiChoice.Checked;
}
if (!lookupObj.Save(SessionState.User.Id))
{
lbError.CssClass = "hc_error";
lbError.Text = LookupGroup.LastError;
lbError.Visible = true;
}
else
{
lbError.Text = "Data saved!";
lbError.CssClass = "hc_success";
lbError.Visible = true;
SessionState.ClearAppLookupGroups();
if (lookupGroupId < 0)
{
lookupGroupId = lookupObj.Id;
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "reloadTab", "<script>DisplayTab(" + lookupObj.Id + ");</script>"); // display new tab
}
}
}
public async Task <LookupGroup> GetItemAsync(string groupName)
{
Enums.LookupGroups lookupGroup;
groupName = groupName.ToCamelCase();
if (Enum.TryParse <Enums.LookupGroups>(groupName, true, out lookupGroup))
{
groupName = lookupGroup.GetDescription().ToCamelCase();
QueryDefinition query = new QueryDefinition("SELECT * FROM c WHERE c.lookupName = @groupName")
.WithParameter("@groupName", groupName);
LookupGroup result = new LookupGroup();
using (FeedIterator <LookupGroup> feedIterator = _container.GetItemQueryIterator <LookupGroup>(query))
{
while (feedIterator.HasMoreResults)
{
FeedResponse <LookupGroup> response = await feedIterator.ReadNextAsync();
foreach (var item in response)
{
result = item;
}
}
}
return(result);
}
return(null);
}
public async Task <LookupGroup> GetItemAsync(string groupName, Guid id)
{
var query = _container.GetItemLinqQueryable <LookupGroup>(true);
LookupGroup lookupItems = query.Where <LookupGroup>(x => x.Name == groupName).AsEnumerable().FirstOrDefault();
LookupGroup lookupItem = lookupItems.Items.SingleOrDefault(x => string.Equals(x.Id, id.ToString(), StringComparison.OrdinalIgnoreCase));
return(lookupItem);
}
public void Apply()
{
LookupGroup lookupGroup = src;
src = dst;
dst = lookupGroup;
dst.Clear();
}
ResolveResult CreateResult(ResolveResult targetResolveResult, List <LookupGroup> lookupGroups, string name, IList <IType> typeArguments)
{
// Remove all hidden groups
lookupGroups.RemoveAll(g => g.AllHidden);
if (lookupGroups.Count == 0)
{
// No members found
return(new UnknownMemberResolveResult(targetResolveResult.Type, name, typeArguments));
}
if (lookupGroups.Any(g => !g.MethodsAreHidden && g.Methods.Count > 0))
{
// If there are methods, make a MethodGroupResolveResult.
// Note that a conflict between a member and a method (possible with multiple interface inheritance)
// is only a warning, not an error, and the C# compiler will prefer the method group.
List <MethodListWithDeclaringType> methodLists = new List <MethodListWithDeclaringType>();
foreach (var lookupGroup in lookupGroups)
{
if (!lookupGroup.MethodsAreHidden && lookupGroup.Methods.Count > 0)
{
var methodListWithDeclType = new MethodListWithDeclaringType(lookupGroup.DeclaringType);
foreach (var method in lookupGroup.Methods)
{
methodListWithDeclType.Add((IMethod)method);
}
methodLists.Add(methodListWithDeclType);
}
}
return(new MethodGroupResolveResult(targetResolveResult, name, methodLists, typeArguments));
}
// If there are ambiguities, report the most-derived result (last group)
LookupGroup resultGroup = lookupGroups[lookupGroups.Count - 1];
if (resultGroup.NestedTypes != null && resultGroup.NestedTypes.Count > 0)
{
if (resultGroup.NestedTypes.Count > 1 || !resultGroup.NonMethodIsHidden || lookupGroups.Count > 1)
{
return(new AmbiguousTypeResolveResult(resultGroup.NestedTypes[0]));
}
else
{
return(new TypeResolveResult(resultGroup.NestedTypes[0]));
}
}
if (lookupGroups.Count > 1)
{
return(new AmbiguousMemberResolveResult(targetResolveResult, resultGroup.NonMethod,
resultGroup.NonMethod.ReturnType.Resolve(context)));
}
else
{
return(new MemberResolveResult(targetResolveResult, resultGroup.NonMethod, context));
}
}
public static bool Matches(this LookupGroup lookupGroup, IReadOnlyList <int> componentTypes)
{
if (lookupGroup.ExcludedComponents.Length == 0)
{
return(ContainsAllRequiredComponents(lookupGroup, componentTypes));
}
return(ContainsAllRequiredComponents(lookupGroup, componentTypes) && !ContainsAnyExcludedComponents(lookupGroup, componentTypes));
}
public static bool Matches(this LookupGroup lookupGroup, IEntity entity)
{
if (lookupGroup.ExcludedComponents.Length == 0)
{
return(ContainsAllRequiredComponents(lookupGroup, entity));
}
return(ContainsAllRequiredComponents(lookupGroup, entity) && !ContainsAnyExcludedComponents(lookupGroup, entity));
}
public static bool ContainsAny(this LookupGroup group, IReadOnlyList <int> components)
{
var requiredContains = group.ContainsAnyRequiredComponents(components);
if (requiredContains)
{
return(true);
}
return(group.ContainsAnyExcludedComponents(components));
}
public ResolveResult LookupType(IType declaringType, string name, IList <IType> typeArguments, bool parameterizeResultType = true)
{
int typeArgumentCount = typeArguments.Count;
Predicate <ITypeDefinition> filter = delegate(ITypeDefinition d) {
return(InnerTypeParameterCount(d) == typeArgumentCount && d.Name == name && IsAccessible(d, true));
};
List <LookupGroup> lookupGroups = new List <LookupGroup>();
if (declaringType.Kind != TypeKind.TypeParameter)
{
foreach (IType type in declaringType.GetNonInterfaceBaseTypes(context))
{
List <IType> newNestedTypes = null;
IEnumerable <IType> typeBaseTypes = null;
IEnumerable <IType> nestedTypes;
if (parameterizeResultType)
{
nestedTypes = type.GetNestedTypes(typeArguments, context, filter, GetMemberOptions.IgnoreInheritedMembers);
}
else
{
nestedTypes = type.GetNestedTypes(context, filter, GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions);
}
AddNestedTypes(type, nestedTypes, typeArgumentCount, lookupGroups, ref typeBaseTypes, ref newNestedTypes);
if (newNestedTypes != null)
{
lookupGroups.Add(new LookupGroup(type, newNestedTypes, null, null));
}
}
}
lookupGroups.RemoveAll(g => g.AllHidden);
Debug.Assert(lookupGroups.All(g => g.NestedTypes != null && g.NestedTypes.Count > 0));
if (lookupGroups.Count == 0)
{
return(new UnknownMemberResolveResult(declaringType, name, typeArguments));
}
LookupGroup resultGroup = lookupGroups[lookupGroups.Count - 1];
if (resultGroup.NestedTypes.Count > 1 || lookupGroups.Count > 1)
{
return(new AmbiguousTypeResolveResult(resultGroup.NestedTypes[0]));
}
else
{
return(new TypeResolveResult(resultGroup.NestedTypes[0]));
}
}
public static bool ContainsAllRequiredComponents(this LookupGroup group, IReadOnlyList <int> componentTypeIds)
{
for (var i = group.RequiredComponents.Length - 1; i >= 0; i--)
{
if (!componentTypeIds.Contains(group.RequiredComponents[i]))
{
return(false);
}
}
return(true);
}
public static bool ContainsAnyRequiredComponents(this LookupGroup group, IReadOnlyList <int> componentTypes)
{
for (var i = group.RequiredComponents.Length - 1; i >= 0; i--)
{
for (var j = componentTypes.Count - 1; j >= 0; j--)
{
if (group.RequiredComponents[i] == componentTypes[j])
{
return(true);
}
}
}
return(false);
}
// Delete current Input form
private void Delete()
{
if (panelId.Visible)
{
LookupGroup lookupObj = LookupGroup.GetByKey(lookupGroupId);
if (!lookupObj.Delete(HyperCatalog.Shared.SessionState.User.Id))
{
lbError.CssClass = "hc_error";
lbError.Text = LookupGroup.LastError;
lbError.Visible = true;
}
else
{
SessionState.ClearAppLookupGroups();
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "clientScript", "<script>back();</script>");
}
}
}
/// <summary>
/// Toolbar action
/// </summary>
/// <param name="sender"></param>
/// <param name="be"></param>
private void uwToolbar_ButtonClicked(object sender, Infragistics.WebUI.UltraWebToolbar.ButtonEvent be)
{
string btn = be.Button.Key.ToLower();
if (btn == "save")
{
Save();
}
if (btn == "delete")
{
Delete();
}
if (btn == "export")
{
string lookupGroupName = LookupGroup.GetByKey(lookupGroupId).Name;
Utils.ExportToExcel(dg, "LookupGroup" + lookupGroupName, lookupGroupName);
}
}
private void BindLookupTable()
{
ViewState["Source"] = "Lookup";
using (LookupGroup lg = HyperCatalog.Business.Container.GetByKey(containerId).Lookup)
{
if (lg != null)
{
if (lg.Values != null)
{
dg.DataSource = lg.Values;
Utils.InitGridSort(ref dg, false);
dg.DataBind();
//ACQ10.0 Starts
UltraGridRow row = new UltraGridRow();
dg.Rows.Insert(0, row);
dg.Rows[0].Cells.FromKey("cChoose").Text = "<input id='rd' type='radio' name='rd' value='##BLANK##' onclick='dc()'/>##BLANK##";
dg.Rows[0].Cells.FromKey("Value").Text = "##BLANK##";
dg.Rows[0].Cells.FromKey("Comment").Text = "To authour ILB ";
//ACQ10.0 Ends
if (!Page.IsPostBack)
{
if (chunk != null)
{
if (chunk.Text == HyperCatalog.Business.Chunk.BlankValue || chunk.Text == HyperCatalog.Business.Chunk.BlankText)
{
dg.Rows[0].Cells.FromKey("cChoose").Text = "<input id='rd' type='radio' name='rd' value='##BLANK##' checked onclick='dc()'/>";
if (bMultiChoice)
{
//dg.Columns.FromKey("InScope").ServerOnly = uwToolbar.Items.FromKeyButton("ilb").Selected = true;
dg.Rows[0].Cells.FromKey("InScope").Value = true;
}
else
{
//dg.Columns.FromKey("cChoose").ServerOnly = uwToolbar.Items.FromKeyButton("ilb").Selected = true;
}
}
}
}
}
}
}
}
public IEnumerable <IEntity> GetEntitiesFor(LookupGroup lookupGroup, params int[] collectionIds)
{
if (lookupGroup.RequiredComponents.Length == 0 && lookupGroup.ExcludedComponents.Length == 0)
{
return(new IEntity[0]);
}
if (collectionIds == null || collectionIds.Length == 0)
{
return(Collections.GetAllEntities().MatchingGroup(lookupGroup));
}
var matchingEntities = new List <IEntity>();
foreach (var collectionName in collectionIds)
{
var results = _collections[collectionName].MatchingGroup(lookupGroup);
matchingEntities.AddRange(results);
}
return(matchingEntities);
}
public bool ReciveList(List <T> dataList)
{
lookupTable.Clear();
groups = null;
lookupTable = new Dictionary <TK2, LookupGroup <T, TK, TK2> >();
foreach (var data in dataList)
{
TK2 k2 = data.GetKey2();
LookupGroup <T, TK, TK2> g = null;
if (!lookupTable.TryGetValue(k2, out g))
{
g = new LookupGroup <T, TK, TK2>();
lookupTable.Add(k2, g);
g.groupId = k2;
}
g.groupedElements.Add(data);
}
groups = lookupTable.Values.KToArray();
return(true);
}
// Display an input form selected
private void UpdateDataEdit(string lookupGroupId)
{
panelGrid.Visible = false;
LookupGroup lookupGroup = LookupGroup.GetByKey(Convert.ToInt32(lookupGroupId));
webTab.Tabs.GetTab(0).ContentPane.TargetUrl = "./lookups/Lookup_Properties.aspx?lg=" + lookupGroupId;
if (lookupGroup == null)
{
webTab.Tabs[1].Visible = false;
lbTitle.Text = "Lookup group: New";
}
else
{
lbTitle.Text = "Lookup group: " + lookupGroup.Name;
webTab.Tabs[1].Visible = true;
webTab.Tabs.GetTab(1).ContentPane.TargetUrl = "./lookups/Lookup_Values.aspx?lg=" + lookupGroupId;
if (lookupGroup.Values != null)
{
webTab.Tabs.GetTab(1).Text = " Values(" + lookupGroup.Values.Count.ToString() + ")";
}
}
panelTabs.Visible = true;
}
public static bool ContainsAnyExcludedComponents(this LookupGroup group, IEntity entity)
{
return(entity.HasAnyComponents(group.ExcludedComponents));
}
public static bool ContainsAny(this LookupGroup group, params int[] components)
{
return(ContainsAny(group, (IReadOnlyList <int>)components));
}
/// <summary>
/// Export the lookups List with values in Excel file
/// </summary>
/// <param name="page"></param>
public static void ExportLookups(Page page)
{
using (LookupGroupList lList = LookupGroup.GetAll())
{
// string contains html code to export
System.Text.StringBuilder sb = new System.Text.StringBuilder(string.Empty);
sb.Append("<html><body>");
sb.Append("<table border='1'>");
#region "Header"
sb.Append("<tr align='center' style='font-size: 14; font-weight: bold; background-color: lightgrey' wordwrap='true'>");
sb.Append("<td>Id</td>");
sb.Append("<td>Name</td>");
sb.Append("<td>Comment</td>");
sb.Append("<td>Multi choice</td>");
sb.Append("<td>Sep</td>");
sb.Append("<td>Value</td>");
sb.Append("<td>Comment</td>");
sb.Append("<td>Sort</td>");
sb.Append("</tr>");
#endregion
string cellColor = "#D0D0D0", defaultCellColor = "#D0D0D0";
for (int i = 0; i < lList.Count; i++)
{
LookupGroup curLookupGroup = lList[i];
LookupValueList lvList = LookupGroup.GetByKey(curLookupGroup.Id).Values;
for (int j = 0; j < lvList.Count; j++)
{
LookupValue curLookupValue = lvList[j];
sb.Append("<tr valign='top' style='background-color: " + cellColor + "; text-color: black;'>");
sb.Append("<td>" + curLookupGroup.Id + "</td>");
sb.Append("<td>" + curLookupGroup.Name + "</td>");
sb.Append("<td>" + curLookupGroup.Comment + "</td>");
sb.Append("<td>" + curLookupGroup.MultiChoice + "</td>");
sb.Append("<td>" + curLookupValue.Text + "</td>");
sb.Append("<td>" + curLookupValue.Comment + "</td>");
sb.Append("<td>" + curLookupValue.Sort + "</td>");
sb.Append("</tr>");
if (cellColor == defaultCellColor)
{
cellColor = "white";
}
else
{
cellColor = defaultCellColor;
}
}
}
sb.Append("</table>");
sb.Append("</body></html>");
string fileName = string.Empty;
fileName += "Lookups.xls";
string exportContent = sb.ToString();
page.Response.Clear();
page.Response.ClearContent();
page.Response.ClearHeaders();
page.Response.Charset = string.Empty;
page.Response.AddHeader("content-disposition", "attachment;filename=" + fileName);
page.Response.ContentType = "application/vnd.ms-excel;";
//Fix for CR 5109 - Prabhu R S
page.Response.ContentEncoding = System.Text.Encoding.UTF8;
page.EnableViewState = false;
page.Response.Write(exportContent);
page.Response.End();
}
}
public async Task <LookupGroup> CreateItemAsync(LookupGroup lookupGroup)
{
var results = await _container.CreateItemAsync <LookupGroup>(lookupGroup, new PartitionKey(lookupGroup.Name));
return(results);
}
public static IEnumerable <IEntity> MatchingGroup(this IEnumerable <IEntity> entities, LookupGroup group)
{
return(entities.Where(x => group.Matches(x)));
}
/// <summary>
/// Export the containers List in Excel file
/// </summary>
/// <param name="page"></param>
public static void ExportContainers(Page page)
{
using (CollectionView cv = new CollectionView(HyperCatalog.Business.Container.GetAll()))
{
cv.Sort("GroupId");
using (CollectionView cvCG = new CollectionView(ContainerGroup.GetAll()))
{
using (CollectionView cvCT = new CollectionView(ContainerType.GetAll()))
{
using (CollectionView cvDT = new CollectionView(DataType.GetAll()))
{
using (CollectionView cvU = new CollectionView(User.GetAll()))
{
using (CollectionView cvLG = new CollectionView(LookupGroup.GetAll()))
{
using (CollectionView cvIM = new CollectionView(InheritanceMethod.GetAll()))
{
// string contains html code to export
System.Text.StringBuilder sb = new System.Text.StringBuilder(string.Empty);
sb.Append("<html><body>");
sb.Append("<table border='1'>");
/******** Writing the User info and Current date ***********/
int ColCount = 28;
sb.Append("<tr style='border: none' valign='top'><td style='font-weight:bold;font-size: 14;border: none; font-family:Arial Unicode MS' colspan=" + ColCount + ">" + "Container Report" + "</td></tr>");
sb.Append("<tr style='border: none' valign='top'><td style='font-weight:bold;border: none; font-size: 14; font-family:Arial Unicode MS'>Generated By: </td><td style='border: none; font-size: 14; font-family:Arial Unicode MS' colspan=" + (ColCount - 1).ToString() + ">" + SessionState.User.FullName + "</td></tr>");
sb.Append("<tr style='border: none' valign='top'><td style='font-weight:bold;border: none; font-size: 14;font-family:Arial Unicode MS'>Exported On: </td><td style='border: none ;font-size: 14; font-family:Arial Unicode MS' colspan=" + (ColCount - 1).ToString() + ">" + SessionState.User.FormatUtcDate(DateTime.UtcNow, true, "MM/dd/yyyy:HH:mm:ss") + "</td></tr>");
#region "Header"
sb.Append("<tr style='font-size: 14; font-weight: bold;font-family:Arial Unicode MS background-color: lightgrey' wordwrap='true'>");
sb.Append("<td>Id</td>");
sb.Append("<td>Container group</td>");
sb.Append("<td>xmlname</td>");
sb.Append("<td>Name</td>");
sb.Append("<td>Label</td>");
sb.Append("<td>Definition</td>");
sb.Append("<td>Entry rule</td>");
sb.Append("<td>Sample</td>");
sb.Append("<td>Data type</td>");
sb.Append("<td>Container type</td>");
sb.Append("<td>Lookup</td>");
sb.Append("<td>Input mask</td>");
sb.Append("<td>Max length</td>");
sb.Append("<td>Translatable</td>");
sb.Append("<td>Regionalizable</td>");
sb.Append("<td>Localizable</td>");
sb.Append("<td>Publishable</td>");
sb.Append("<td>Readonly</td>");
sb.Append("<td>Keep if obsolete</td>");
sb.Append("<td>Inheritance method</td>");
sb.Append("<td>Sort</td>");
sb.Append("<td>Segment</td>");
sb.Append("<td>ValidationMask</td>");
sb.Append("<td>WWXPath</td>");
sb.Append("<td>Creator</td>");
sb.Append("<td>Create date</td>");
sb.Append("<td>Modifier</td>");
sb.Append("<td>Modifier date</td>");
sb.Append("</tr>");
#endregion
string cellColor = "#D0D0D0", defaultCellColor = "#D0D0D0";
for (int i = 0; i < cv.Count; i++)
{
Container curContainer = ((Container)cv[i]);
sb.Append("<tr valign='top' style='font-size: 14; font-family:Arial Unicode MS;background-color: " + cellColor + ";text-color: black;'>");
sb.Append("<td>" + curContainer.Id + "</td>");
//********************************************************************************************
//GADSC Code Change for displaying the Goup/Subgroup path of the container group in the report
//Ezilla Bug N0:68758
//Modified By:Kanthi.J
//********************************************************************************************
cvCG.ApplyFilter("Id", curContainer.GroupId, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((ContainerGroup)cvCG[0]).Path + ((ContainerGroup)cvCG[0]).Name + "</td>");
sb.Append("<td>" + curContainer.Tag + "</td>");
sb.Append("<td>" + curContainer.Name + "</td>");
sb.Append("<td>" + curContainer.Label + "</td>");
sb.Append("<td>" + curContainer.Definition + "</td>");
sb.Append("<td>" + curContainer.EntryRule + "</td>");
sb.Append("<td>" + curContainer.Sample + "</td>");
cvDT.ApplyFilter("Code", curContainer.DataTypeCode, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((DataType)cvDT[0]).Name + "</td>");
cvCT.ApplyFilter("Code", curContainer.ContainerTypeCode, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((ContainerType)cvCT[0]).Name + "</td>");
if (curContainer.LookupId == -1)
{
sb.Append("<td></td>");
}
else
{
cvLG.ApplyFilter("Id", curContainer.LookupId, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((LookupGroup)cvLG[0]).Name + "</td>");
}
sb.Append("<td>" + curContainer.InputMask + "</td>");
sb.Append("<td>" + curContainer.MaxLength + "</td>");
sb.Append("<td>" + curContainer.Translatable + "</td>");
sb.Append("<td>" + curContainer.Regionalizable + "</td>");
sb.Append("<td>" + curContainer.Localizable + "</td>");
sb.Append("<td>" + curContainer.Publishable + "</td>");
sb.Append("<td>" + curContainer.ReadOnly + "</td>");
sb.Append("<td>" + curContainer.KeepIfObsolete + "</td>");
cvIM.ApplyFilter("Id", curContainer.InheritanceMethodId, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((InheritanceMethod)cvIM[0]).Name + "</td>");
sb.Append("<td>" + curContainer.Sort + "</td>");
sb.Append("<td>" + curContainer.SegmentId + "</td>");
sb.Append("<td>" + curContainer.ValidationMask + "</td>");
sb.Append("<td>" + curContainer.WWXPath + "</td>");
cvU.ApplyFilter("Id", curContainer.CreatorId, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
sb.Append("<td>" + ((User)cvU[0]).FullName + "</td>");
sb.Append("<td>" + curContainer.CreateDate + "</td>");
if (curContainer.ModifierId == -1)
{
sb.Append("<td></td>");
}
else
{
cvU.ApplyFilter("Id", curContainer.ModifierId, HyperCatalog.Business.CollectionView.FilterOperand.Equals);
}
sb.Append("<td>" + ((User)cvU[0]).FullName + "</td>");
sb.Append("<td>" + curContainer.ModifyDate + "</td>");
sb.Append("</tr>");
if (cellColor == defaultCellColor)
{
cellColor = "white";
}
else
{
cellColor = defaultCellColor;
}
}
sb.Append("</table>");
sb.Append("</body></html>");
string fileName = string.Empty;
fileName += "Containers.xls";
string exportContent = sb.ToString();
page.Response.Clear();
page.Response.ClearContent();
page.Response.ClearHeaders();
page.Response.Charset = string.Empty;
page.Response.AddHeader("content-disposition", "attachment;filename=" + fileName);
page.Response.ContentType = "application/vnd.ms-excel;";
//Fix for CR 5109 - Prabhu R S
page.Response.ContentEncoding = System.Text.Encoding.UTF8;
page.EnableViewState = false;
page.Response.Write(exportContent);
page.Response.End();
}
}
}
}
}
}
}
}
Expression CreateResult(Expression targetExpression, List <LookupGroup> lookupGroups, string name, IList <IType> typeArguments)
{
// Remove all hidden groups
lookupGroups.RemoveAll(g => g.AllHidden);
if (lookupGroups.Count == 0)
{
// No members found
return(new UnknownMemberExpression(targetExpression.Type, name, typeArguments));
}
if (lookupGroups.Any(g => !g.MethodsAreHidden && g.Methods.Count > 0))
{
// If there are methods, make a MethodGroupResolveResult.
// Note that a conflict between a member and a method (possible with multiple interface inheritance)
// is only a warning, not an error, and the V# compiler will prefer the method group.
List <MethodListWithDeclaringType> methodLists = new List <MethodListWithDeclaringType>();
foreach (var lookupGroup in lookupGroups)
{
if (!lookupGroup.MethodsAreHidden && lookupGroup.Methods.Count > 0)
{
var methodListWithDeclType = new MethodListWithDeclaringType(lookupGroup.DeclaringType);
foreach (var method in lookupGroup.Methods)
{
methodListWithDeclType.Add((IMethod)method);
}
methodLists.Add(methodListWithDeclType);
}
}
return(new MethodGroupExpression(targetExpression, name, methodLists, typeArguments));
}
// If there are ambiguities, report the most-derived result (last group)
LookupGroup resultGroup = lookupGroups[lookupGroups.Count - 1];
if (resultGroup.NestedTypes != null && resultGroup.NestedTypes.Count > 0)
{
if (resultGroup.NestedTypes.Count > 1 || !resultGroup.NonMethodIsHidden || lookupGroups.Count > 1)
{
// return new AmbiguousTypeResolveResult(resultGroup.NestedTypes[0]); // TODO:ERROR AMBIGIOUS
return(null);
}
else
{
return(new TypeExpression(resultGroup.NestedTypes[0]));
}
}
if (resultGroup.NonMethod.IsStatic && targetExpression is SelfReference)
{
targetExpression = new TypeExpression(targetExpression.Type);
}
if (lookupGroups.Count > 1)
{
throw new ArgumentException(string.Format("Ambigious member {1} found on target {0}",
targetExpression.GetSignatureForError(), resultGroup.NonMethod));
}
else
{
if (isInEnumMemberInitializer)
{
IField field = resultGroup.NonMethod as IField;
if (field != null && field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
{
return(new MemberExpressionStatement(
targetExpression, field,
field.DeclaringTypeDefinition.EnumUnderlyingType,
field.IsConst, field.ConstantValue));
}
}
return(new MemberExpressionStatement(targetExpression, resultGroup.NonMethod));
}
}
ResolveResult CreateResult(ResolveResult targetResolveResult, List <LookupGroup> lookupGroups, string name, IReadOnlyList <IType> typeArguments)
{
// Remove all hidden groups
lookupGroups.RemoveAll(g => g.AllHidden);
if (lookupGroups.Count == 0)
{
// No members found
return(new UnknownMemberResolveResult(targetResolveResult.Type, name, typeArguments));
}
if (lookupGroups.Any(g => !g.MethodsAreHidden && g.Methods.Count > 0))
{
// If there are methods, make a MethodGroupResolveResult.
// Note that a conflict between a member and a method (possible with multiple interface inheritance)
// is only a warning, not an error, and the C# compiler will prefer the method group.
List <MethodListWithDeclaringType> methodLists = new List <MethodListWithDeclaringType>();
foreach (var lookupGroup in lookupGroups)
{
if (!lookupGroup.MethodsAreHidden && lookupGroup.Methods.Count > 0)
{
var methodListWithDeclType = new MethodListWithDeclaringType(lookupGroup.DeclaringType);
foreach (var method in lookupGroup.Methods)
{
methodListWithDeclType.Add((IMethod)method);
}
methodLists.Add(methodListWithDeclType);
}
}
return(new MethodGroupResolveResult(targetResolveResult, name, methodLists, typeArguments));
}
// If there are ambiguities, report the most-derived result (last group)
LookupGroup resultGroup = lookupGroups[lookupGroups.Count - 1];
if (resultGroup.NestedTypes != null && resultGroup.NestedTypes.Count > 0)
{
if (resultGroup.NestedTypes.Count > 1 || !resultGroup.NonMethodIsHidden || lookupGroups.Count > 1)
{
return(new AmbiguousTypeResolveResult(resultGroup.NestedTypes[0]));
}
else
{
return(new TypeResolveResult(resultGroup.NestedTypes[0]));
}
}
if (resultGroup.NonMethod.IsStatic && targetResolveResult is ThisResolveResult)
{
targetResolveResult = new TypeResolveResult(targetResolveResult.Type);
}
if (lookupGroups.Count > 1)
{
return(new AmbiguousMemberResolveResult(targetResolveResult, resultGroup.NonMethod));
}
else
{
if (isInEnumMemberInitializer)
{
IField field = resultGroup.NonMethod as IField;
if (field != null && field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
{
return(new MemberResolveResult(
targetResolveResult, field,
field.DeclaringTypeDefinition.EnumUnderlyingType,
field.IsConst, field.GetConstantValue()));
}
}
return(new MemberResolveResult(targetResolveResult, resultGroup.NonMethod));
}
}
public static bool ContainsAllRequiredComponents(this LookupGroup group, params int[] componentTypeIds)
{
return(ContainsAllRequiredComponents(group, (IReadOnlyList <int>)componentTypeIds));
}
