public static CswNbtView LocationPropertyView(CswNbtResources CswNbtResources, CswNbtMetaDataNodeTypeProp Prop, CswPrimaryKey NodeId = null, IEnumerable <CswPrimaryKey> InventoryGroupIds = null, CswEnumNbtFilterResultMode ResultMode = null, string FullPathFilter = "")
{
CswNbtMetaDataObjectClass ContainerOC = CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
CswNbtMetaDataObjectClass UserOC = CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.UserClass);
CswNbtMetaDataObjectClass RequestItemOC = CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
//TODO (Case 31016): This is pretty hack-a-delic - we should convert these into prop attributes (like RespectAllowInventory, DisableLowestLevel, and IncludeRoot)
bool IsLocationNode = (null != Prop && Prop.getNodeType().getObjectClass().ObjectClass == CswEnumNbtObjectClass.LocationClass);
bool IsContainerNode = (null != Prop && null != ContainerOC && Prop.getNodeType().ObjectClassId == ContainerOC.ObjectClassId);
bool IsUserNode = (null != Prop && null != UserOC && Prop.getNodeType().ObjectClassId == UserOC.ObjectClassId);
bool IsRequestItemNode = (null != Prop && null != RequestItemOC && Prop.getNodeType().ObjectClassId == RequestItemOC.ObjectClassId);
CswNbtView Ret = new CswNbtView(CswNbtResources);
Ret.ViewName = GetTopLevelName(CswNbtResources);
Ret.Root.Included = IsLocationNode;
CswNbtObjClassLocation.makeLocationsTreeView(ref Ret, CswNbtResources,
NodeIdToFilterOut: NodeId,
RequireAllowInventory: (CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Containers) && (IsContainerNode || IsUserNode || IsRequestItemNode)),
InventoryGroupIds: InventoryGroupIds,
DisableLowestLevel: IsLocationNode,
ResultMode: ResultMode,
FullPathFilter: FullPathFilter);
return(Ret);
}
public CswViewBuilderProp(CswNbtMetaDataNodeTypeProp NodeTypeProp)
{
CswNbtMetaDataNodeType nt = NodeTypeProp.getNodeType();
if (null != nt)
{
OwnerName = nt.NodeTypeName;
}
FieldType = NodeTypeProp.getFieldTypeValue();
//ListOptions.FromString( NodeTypeProp.ListOptions );
ListOptions.FromString(NodeTypeProp.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Options].AsText.Text);
RelatedIdType = CswEnumNbtViewRelatedIdType.NodeTypeId;
MetaDataPropNameWithQuestionNo = NodeTypeProp.PropNameWithQuestionNo;
MetaDataPropId = NodeTypeProp.FirstPropVersionId;
MetaDataPropName = NodeTypeProp.PropName;
MetaDataTypeName = NodeTypeProp.getNodeType().NodeTypeName;
FieldTypeRule = NodeTypeProp.getFieldTypeRule();
Type = CswEnumNbtViewPropType.NodeTypePropId;
PropName = MetaDataPropName;
AssociatedPropIds.Add(MetaDataPropId.ToString());
if (NodeTypeProp.ObjectClassPropId != Int32.MinValue)
{
AssociatedPropIds.Add(NodeTypeProp.ObjectClassPropId.ToString());
}
} //ctor Ntp
public void addSingleNodeProp(CswNbtNode Node, JObject PropObj, CswNbtMetaDataNodeTypeTab Tab)
{
CswPropIdAttr PropIdAttr = new CswPropIdAttr(CswConvert.ToString(PropObj["id"]));
CswNbtMetaDataNodeTypeProp MetaDataProp = _CswNbtResources.MetaData.getNodeTypeProp(PropIdAttr.NodeTypePropId);
if (null != MetaDataProp)
{
CswNbtMetaDataNodeType NodeType = MetaDataProp.getNodeType();
if (_CswNbtResources.Permit.canNodeType(Security.CswEnumNbtNodeTypePermission.Edit, NodeType) ||
_CswNbtResources.Permit.canTab(Security.CswEnumNbtNodeTypePermission.Edit, NodeType, Tab) ||
_CswNbtResources.Permit.isPropWritable(Security.CswEnumNbtNodeTypePermission.Edit, MetaDataProp, Tab))
{
Node.Properties[MetaDataProp].ReadJSON(PropObj, null, null);
// Recurse on sub-props
if (null != PropObj["subprops"])
{
JObject SubPropsObj = (JObject)PropObj["subprops"];
if (SubPropsObj.HasValues)
{
foreach (JObject ChildPropObj in SubPropsObj.Properties()
.Where(ChildProp => null != ChildProp.Value && ChildProp.Value.HasValues)
.Select(ChildProp => (JObject)ChildProp.Value)
.Where(ChildPropObj => ChildPropObj.HasValues))
{
addSingleNodeProp(Node, ChildPropObj, Tab);
}
}
}
} //if user has permission to edit the property
} //if not null
} // addSingleNodeProp()
private bool _canViewProp(int NodeTypePropId, CswPrimaryKey PermissionGroupId)
{
CswNbtMetaDataNodeTypeProp NTProp = _CswNbtResources.MetaData.getNodeTypeProp(NodeTypePropId);
// Must have permission to at least one tab where this property appears
Dictionary <Int32, CswNbtMetaDataNodeTypeLayoutMgr.NodeTypeLayout> EditLayouts = NTProp.getEditLayouts();
bool canView = EditLayouts.Values.Aggregate(false,
(current, EditLayout) => current || _CswNbtResources.Permit.canTab(
CswEnumNbtNodeTypePermission.View,
NTProp.getNodeType(),
_CswNbtResources.MetaData.getNodeTypeTab(EditLayout.TabId)));
#region Container Request Button Inventory Group Permission
if (canView)
{
CswNbtMetaDataObjectClass ContainerClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
if (null != ContainerClass)
{
CswNbtMetaDataObjectClassProp RequestProp = _CswNbtResources.MetaData.getObjectClassProp(ContainerClass.ObjectClassId, CswNbtObjClassContainer.PropertyName.Request);
if (NTProp.ObjectClassPropId == RequestProp.PropId)
{
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Requesting))
{
canView = CswNbtObjClassContainer.canContainer(_CswNbtResources, _CswNbtResources.Actions[CswEnumNbtActionName.Submit_Request], PermissionGroupId);
}
else
{
canView = false; // case 31851
}
}
}
}
#endregion
#region Material Receive Button View Permission
if (canView)
{
CswNbtMetaDataObjectClass MaterialClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ChemicalClass);
if (null != MaterialClass)
{
CswNbtMetaDataObjectClassProp RequestProp = _CswNbtResources.MetaData.getObjectClassProp(MaterialClass.ObjectClassId, CswNbtPropertySetMaterial.PropertyName.Receive);
if (NTProp.ObjectClassPropId == RequestProp.PropId)
{
canView = _CswNbtResources.Permit.can(CswEnumNbtActionName.Receiving);
}
}
}
#endregion
return(canView);
}
} //isPropWritable
/// <summary>
/// Determines if the Property is editable
/// </summary>
public bool isPropWritable(CswEnumNbtNodeTypePermission Permission, CswNbtMetaDataNodeTypeProp MetaDataProp, CswNbtMetaDataNodeTypeTab MetaDataTab, CswNbtNodePropWrapper NodePropWrapper, CswNbtObjClassRole Role)
{
bool ret = false;
if (null != MetaDataProp)
{
_initPermissionInfo(Role, null, MetaDataProp.getNodeType(), Permission, ((null != NodePropWrapper) ? NodePropWrapper.NodeId : null), MetaDataProp);
ret = _isPropWritableImpl(MetaDataTab, MetaDataProp, NodePropWrapper);
} //if-else we have metadata prop
return(ret);
} //isPropWritable
} // updatePropLayout()
public void updatePropLayout(CswEnumNbtLayoutType LayoutType, CswNbtMetaDataNodeTypeProp Prop, CswNbtMetaDataNodeTypeProp InsertAfterProp, bool DoMove)
{
bool Added = false;
if (DoMove)
{
removePropFromLayout(LayoutType, Prop, Int32.MinValue);
}
if (InsertAfterProp != null)
{
Dictionary <Int32, NodeTypeLayout> InsertAfterPropLayouts = getLayout(LayoutType, InsertAfterProp, null);
if (InsertAfterPropLayouts.Values.Count > 0)
{
foreach (Int32 TabId in InsertAfterPropLayouts.Keys)
{
NodeTypeLayout InsertAfterPropLayout = InsertAfterPropLayouts[TabId];
// Make space for the new prop
CswTableUpdate LayoutUpdate = _CswNbtMetaDataResources.CswNbtResources.makeCswTableUpdate("makeSpaceForProp_Update", "nodetype_layout");
string WhereClause = "where layouttype = '" + LayoutType.ToString() + "' and nodetypeid = " + InsertAfterProp.NodeTypeId.ToString();
if (TabId != Int32.MinValue && LayoutType == CswEnumNbtLayoutType.Edit)
{
WhereClause += " and nodetypetabsetid = " + TabId.ToString();
}
DataTable LayoutTable = LayoutUpdate.getTable(WhereClause);
foreach (DataRow Row in LayoutTable.Rows)
{
if (CswConvert.ToInt32(Row["display_column"]) == InsertAfterPropLayout.DisplayColumn &&
CswConvert.ToInt32(Row["display_row"]) > InsertAfterPropLayout.DisplayRow)
{
Row["display_row"] = CswConvert.ToDbVal(CswConvert.ToInt32(Row["display_row"]) + 1);
}
}
LayoutUpdate.update(LayoutTable);
// Add new prop to the layout
updatePropLayout(LayoutType, Prop.NodeTypeId, Prop, false, TabId, InsertAfterPropLayout.DisplayRow + 1, InsertAfterPropLayout.DisplayColumn, InsertAfterPropLayout.TabGroup);
Added = true;
} // foreach( Int32 TabId in InsertAfterPropLayouts.Keys )
} // if( InsertAfterPropLayouts.Values.Count > 0 )
} // if( InsertAfterProp != null )
if (false == Added)
{
// Just add it somewhere
updatePropLayout(LayoutType, Prop.NodeTypeId, Prop, false, Prop.getNodeType().getFirstNodeTypeTab().TabId);
}
if (_Cache.ContainsKey(Prop.NodeTypeId))
{
_Cache.Remove(Prop.NodeTypeId);
}
} // updatePropLayout()
public void afterCreateNodeTypeProp(CswNbtMetaDataNodeTypeProp NodeTypeProp)
{
//Case 53001 - grid properties need to have the the current NT set as the root
CswNbtView propView = _CswNbtFieldResources.CswNbtResources.ViewSelect.restoreView(NodeTypeProp.ViewId);
propView.SetViewMode(CswEnumNbtViewRenderingMode.Grid);
propView.AddViewRelationship(NodeTypeProp.getNodeType(), true);
propView.save();
_CswNbtFieldTypeRuleDefault.afterCreateNodeTypeProp(NodeTypeProp);
}
public CswNbtNodePropWrapper this[CswNbtMetaDataNodeTypeProp NodeTypeProp]
{
get
{
CswNbtMetaDataNodeType NodeType = _CswNbtNode.getNodeType();
if (NodeTypeProp == null)
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid Property", "CswNbtNodePropColl[] was passed a null CswNbtMetaDataNodeTypeProp object");
}
if (NodeTypeProp.getNodeType().FirstVersionNodeTypeId != NodeType.FirstVersionNodeTypeId)
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid Property", "CswNbtNodePropColl[] on nodetype " + NodeType.NodeTypeName + " (" + NodeType.NodeTypeId + ") was passed a CswNbtMetaDataNodeTypeProp: " + NodeTypeProp.PropName + " (" + NodeTypeProp.PropId + ") of the wrong nodetype: " + NodeTypeProp.getNodeType().NodeTypeName + " (" + NodeTypeProp.NodeTypeId + ")");
}
if (false == _PropsIndexByFirstVersionPropId.ContainsKey(NodeTypeProp.FirstPropVersionId))
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid Property", "There is no property with this firstpropversionid " + NodeTypeProp.FirstPropVersionId.ToString() + " on nodetypeid " + NodeType.NodeTypeId.ToString());
}
return(_Props[_PropsIndexByFirstVersionPropId[NodeTypeProp.FirstPropVersionId]]);
} //get
} //this[NodeTypeProp]
/// <summary>
/// Returns true if the relationship is invalid
/// </summary>
private bool _isInvalidRelationship(CswEnumNbtViewRelatedIdType RelatedIdType, Int32 FkValue, CswEnumNbtViewPropIdType inValuePropType, Int32 inValuePropId)
{
bool RetIsInvalid = false;
//if( RelatedIdType == NbtViewRelatedIdType.NodeTypeId )
//{
// CswNbtMetaDataNodeType FkRelationshipTargetNt = _CswNbtFieldResources.CswNbtResources.MetaData.getNodeType( FkValue );
// RetIsInvalid = ( null == FkRelationshipTargetNt );
// if( false == RetIsInvalid )
// {
// CswNbtMetaDataNodeTypeProp ValueNtp = _CswNbtFieldResources.CswNbtResources.MetaData.getNodeTypeProp( inValuePropId );
// RetIsInvalid = ( null == ValueNtp ||
// _CswNbtFieldResources.CswNbtResources.MetaData.getNodeTypeFirstVersion( ValueNtp.NodeTypeId ) != FkRelationshipTargetNt.getFirstVersionNodeType() );
// }
//}
//else if( RelatedIdType == NbtViewRelatedIdType.ObjectClassId )
//{
// CswNbtMetaDataObjectClass FkRelationshipTargetOc = _CswNbtFieldResources.CswNbtResources.MetaData.getObjectClass( FkValue );
// RetIsInvalid = ( null == FkRelationshipTargetOc );
// if( false == RetIsInvalid )
// {
// CswNbtMetaDataObjectClassProp ValueOcp = _CswNbtFieldResources.CswNbtResources.MetaData.getObjectClassProp( inValuePropId );
// RetIsInvalid = ( null == ValueOcp || ( ValueOcp.getObjectClass().ObjectClass != FkRelationshipTargetOc.ObjectClass ) );
// }
//}
//else if( RelatedIdType == NbtViewRelatedIdType.PropertySetId )
//{
// CswNbtMetaDataPropertySet FkRelationshipTargetPs = _CswNbtFieldResources.CswNbtResources.MetaData.getPropertySet( FkValue );
// RetIsInvalid = ( null == FkRelationshipTargetPs );
// if( false == RetIsInvalid )
// {
// CswNbtMetaDataObjectClassProp ValueOcp = _CswNbtFieldResources.CswNbtResources.MetaData.getObjectClassProp( inValuePropId );
// RetIsInvalid = ( null == ValueOcp ||
// null == ValueOcp.getObjectClass().getPropertySet() ||
// ValueOcp.getObjectClass().getPropertySet().Name != FkRelationshipTargetPs.Name );
// }
//}
if (inValuePropType == CswEnumNbtViewPropIdType.NodeTypePropId)
{
CswNbtMetaDataNodeTypeProp ValuePropNTP = _CswNbtFieldResources.CswNbtResources.MetaData.getNodeTypeProp(inValuePropId);
RetIsInvalid = false == (CswNbtViewRelationship.Matches(_CswNbtFieldResources.CswNbtResources, RelatedIdType, FkValue, ValuePropNTP.getNodeType()));
}
else if (inValuePropType == CswEnumNbtViewPropIdType.ObjectClassPropId)
{
CswNbtMetaDataObjectClassProp ValuePropOCP = _CswNbtFieldResources.CswNbtResources.MetaData.getObjectClassProp(inValuePropId);
RetIsInvalid = false == (CswNbtViewRelationship.Matches(_CswNbtFieldResources.CswNbtResources, RelatedIdType, FkValue, ValuePropOCP.getObjectClass()));
}
return(RetIsInvalid);
}
public static void getBlob(ICswResources CswResources, BlobDataReturn Return, BlobDataParams Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
DataTable blobDataTbl;
int BlobDataId = CswConvert.ToInt32(Request.Blob.BlobDataId);
int PropId = _getNodeTypePropIdFromJctNodePropId(NbtResources, CswConvert.ToInt32(Request.propid));
CswNbtMetaDataNodeTypeProp MetaDataProp = NbtResources.MetaData.getNodeTypeProp(PropId);
if (NbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.View, MetaDataProp.getNodeType(), NbtResources.CurrentNbtUser))
{
//Get the file from blob_data
if (String.IsNullOrEmpty(Request.date))
{
CswTableSelect blobDataSelect = NbtResources.makeCswTableSelect("getBlob", "blob_data");
string whereClause = "where jctnodepropid = " + Request.propid;
if (Int32.MinValue != BlobDataId)
{
whereClause += " and blobdataid = " + Request.Blob.BlobDataId;
}
blobDataTbl = blobDataSelect.getTable(whereClause);
}
else //get the audited record
{
int jctnodepropid = CswConvert.ToInt32(Request.propid);
CswArbitrarySelect blobDataAuditSelect = CswNbtSdBlobData.GetBlobAuditSelect(NbtResources, Request.date, jctnodepropid, BlobDataId);
blobDataTbl = blobDataAuditSelect.getTable();
}
foreach (DataRow row in blobDataTbl.Rows)
{
Request.data = row["blobdata"] as byte[];
Request.Blob.FileName = row["filename"].ToString();
Request.Blob.ContentType = row["contenttype"].ToString();
}
if (null == Request.data || Request.data.Length == 0)
{
bool UseNTPlaceHolder = CswConvert.ToBoolean(Request.usenodetypeasplaceholder);
if (UseNTPlaceHolder)
{
CswPrimaryKey NodeId = CswConvert.ToPrimaryKey(Request.nodeid);
CswNbtNode Node = NbtResources.Nodes[NodeId];
if (null != Node)
{
CswNbtMetaDataNodeType NodeType = Node.getNodeType();
if (null != NodeType && NodeType.IconFileName != string.Empty)
{
Request.Blob.FileName = NodeType.IconFileName;
Request.Blob.ContentType = "image/png";
Request.data = File.ReadAllBytes(Request.appPath + CswNbtMetaDataObjectClass.IconPrefix100 + NodeType.IconFileName);
}
}
}
else
{
Request.data = File.ReadAllBytes(Request.appPath + "/Images/icons/300/_placeholder.gif");
Request.Blob.ContentType = "image/gif";
Request.Blob.FileName = "empty.gif";
}
}
Return.Data = Request;
} // NbtResources.Permit.canNodeType()
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do no have sufficient priveledges to fetch this file.", "User " + NbtResources.CurrentNbtUser.UserId + " tried to fetch a file " + PropId + " they do not have permission on.");
}
}
public static void clearBlob(ICswResources CswResources, BlobDataReturn Return, BlobDataParams Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswPropIdAttr PropId = new CswPropIdAttr(Request.propid);
CswNbtNode Node = NbtResources.Nodes[PropId.NodeId];
if (null != Node)
{
CswNbtMetaDataNodeTypeProp MetaDataProp = NbtResources.MetaData.getNodeTypeProp(PropId.NodeTypePropId);
if (null != MetaDataProp)
{
CswNbtNodePropWrapper FileProp = Node.Properties[MetaDataProp];
if (NbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, MetaDataProp.getNodeType(), NbtResources.CurrentNbtUser) &&
NbtResources.Permit.isPropWritable(CswEnumNbtNodeTypePermission.Edit, MetaDataProp, null, FileProp))
{
CswNbtSdTabsAndProps tabsandprops = new CswNbtSdTabsAndProps(NbtResources);
tabsandprops.ClearPropValue(Request.propid, true);
Request.Blob = new CswNbtSdBlobData.CswNbtBlob();
Request.success = true;
Return.Data = Request;
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do not have sufficient priveledges to clear this File property", "User " + NbtResources.CurrentNbtUser.UserId + " attempted to call clearBlob without sufficient priviledges.");
}
}
}
}
public static void clearImage(ICswResources CswResources, NodePropImageReturn Return, BlobDataParams Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswPropIdAttr PropId = new CswPropIdAttr(Request.propid);
CswNbtNode Node = NbtResources.Nodes[PropId.NodeId];
if (null != Node)
{
CswNbtMetaDataNodeTypeProp MetaDataProp = NbtResources.MetaData.getNodeTypeProp(PropId.NodeTypePropId);
if (null != MetaDataProp)
{
CswNbtNodePropWrapper FileProp = Node.Properties[MetaDataProp];
if (NbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, MetaDataProp.getNodeType(), NbtResources.CurrentNbtUser) &&
NbtResources.Permit.isPropWritable(CswEnumNbtNodeTypePermission.Edit, MetaDataProp, null, FileProp))
{
int BlobDataId = Request.Blob.BlobDataId;
CswTableUpdate blobDataTS = NbtResources.makeCswTableUpdate("clearImage", "blob_data");
DataTable blobDataTbl = blobDataTS.getTable("where blobdataid = " + BlobDataId);
foreach (DataRow row in blobDataTbl.Rows)
{
row.Delete();
}
blobDataTS.update(blobDataTbl);
Request.Blob = new CswNbtSdBlobData.CswNbtBlob();
Request.success = true;
getImageProp(CswResources, Return, Request);
}
}
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do not have sufficient priveledges to clear this Image property", "User " + NbtResources.CurrentNbtUser.UserId + " attempted to call clearImg without sufficient priviledges.");
}
}
}// this[ string ObjectClassPropName ]
public bool Contains(CswNbtMetaDataNodeTypeProp NodeTypeProp)
{
return(NodeTypeProp != null &&
NodeTypeProp.getNodeType().FirstVersionNodeTypeId == _CswNbtNode.getNodeType().FirstVersionNodeTypeId&&
_PropsIndexByFirstVersionPropId.ContainsKey(NodeTypeProp.FirstPropVersionId));
}
public int saveFile(string PropIdAttr, byte[] BlobData, string ContentType, string FileName, out string Href, int BlobDataId = Int32.MinValue, bool PostChanges = true, CswNbtNode Node = null)
{
CswPropIdAttr PropId = new CswPropIdAttr(PropIdAttr);
CswNbtMetaDataNodeTypeProp MetaDataProp = _CswNbtResources.MetaData.getNodeTypeProp(PropId.NodeTypePropId);
if (null == Node)
{
Node = _CswNbtResources.Nodes[PropId.NodeId];
}
CswNbtNodePropWrapper FileProp = Node.Properties[MetaDataProp];
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, MetaDataProp.getNodeType(), _CswNbtResources.CurrentNbtUser) &&
_CswNbtResources.Permit.isPropWritable(CswEnumNbtNodeTypePermission.Edit, MetaDataProp, null, FileProp))
{
if (Int32.MinValue == FileProp.JctNodePropId)
{
FileProp.makePropRow(); //if we don't have a jct_node_prop row for this prop, we do now
if (PostChanges)
{
Node.postChanges(true);
}
}
if (FileProp.getFieldType().FieldType == CswEnumNbtFieldType.Image)
{
//case 29692: support EXIF image rotation metadata to properly orient photos
bool img_ok = false;
MemoryStream ms = new MemoryStream(BlobData, 0, BlobData.Length);
ms.Write(BlobData, 0, BlobData.Length);
System.Drawing.Image img = null;
try
{
img = Image.FromStream(ms, true);
img_ok = true;
}
catch
{
}
if (img_ok == true)
{
FixOrientation(ref img);
ImageConverter converter = new ImageConverter();
BlobData = (byte[])converter.ConvertTo(img, typeof(byte[]));
}
}
//Save the file to blob_data
CswTableUpdate BlobUpdate = _CswNbtResources.makeCswTableUpdate("saveBlob", "blob_data");
string whereClause = "where jctnodepropid = " + FileProp.JctNodePropId;
if (Int32.MinValue != BlobDataId)
{
whereClause += " and blobdataid = " + BlobDataId;
}
DataTable BlobTbl = BlobUpdate.getTable(whereClause);
if (BlobTbl.Rows.Count > 0 &&
(Int32.MinValue != BlobDataId ||
FileProp.getFieldTypeValue() == CswEnumNbtFieldType.File ||
FileProp.getFieldTypeValue() == CswEnumNbtFieldType.MOL))
{
BlobTbl.Rows[0]["blobdata"] = BlobData;
BlobTbl.Rows[0]["contenttype"] = ContentType;
BlobTbl.Rows[0]["filename"] = FileName;
BlobTbl.Rows[0]["auditlevel"] = MetaDataProp.AuditLevel;
BlobDataId = CswConvert.ToInt32(BlobTbl.Rows[0]["blobdataid"]);
}
else
{
DataRow NewRow = BlobTbl.NewRow();
NewRow["jctnodepropid"] = FileProp.JctNodePropId;
NewRow["blobdata"] = BlobData;
NewRow["contenttype"] = ContentType;
NewRow["filename"] = FileName;
NewRow["auditlevel"] = MetaDataProp.AuditLevel;
BlobDataId = CswConvert.ToInt32(NewRow["blobdataid"]);
BlobTbl.Rows.Add(NewRow);
}
BlobUpdate.update(BlobTbl);
if (Node.getObjectClass().ObjectClass == CswEnumNbtObjectClass.ReportClass)
{
CswNbtObjClassReport Report = Node;
CswFilePath FilePathTools = new CswFilePath(_CswNbtResources);
string ReportPath = FilePathTools.getFullReportFilePath(Report.RPTFile.JctNodePropId.ToString());
_createReportFile(ReportPath, Report.RPTFile.JctNodePropId, BlobData);
}
if (CswEnumNbtFieldType.File == FileProp.getFieldTypeValue())
{
SetLastModified(FileProp);
}
FileProp.SyncGestalt();
if (PostChanges)
{
Node.postChanges(false);
}
Href = CswNbtNodePropBlob.getLink(FileProp.JctNodePropId, PropId.NodeId, BlobDataId);
} //canNodeType() && isPropWritable()
else
{
Href = string.Empty; //To satifsy the "ref string Href"
throw new CswDniException(CswEnumErrorType.Error, "You do not have sufficient priveledges to save files", "User " + _CswNbtResources.CurrentNbtUser.UserId + " attemped to save blobdata on JctNodeProp " + FileProp.JctNodePropId);
}
return(BlobDataId);
}
} // _getOptions()
#endregion Relationship Properties and Functions
#region Serialization
public override void ToJSON(JObject ParentObject)
{
bool allowAdd = false;
ParentObject["nodetypeid"] = string.Empty;
ParentObject["objectclassid"] = string.Empty;
if (RelationshipType == CswEnumNbtViewPropIdType.NodeTypePropId)
{
CswNbtMetaDataNodeTypeProp RelationshipNTP = _CswNbtResources.MetaData.getNodeTypeProp(RelationshipId);
CswNbtMetaDataNodeType RelationshipNT = RelationshipNTP.getNodeType();
if (null != RelationshipNT)
{
ParentObject["nodetypeid"] = RelationshipNT.NodeTypeId;
CswNbtMetaDataObjectClass RelationshipOC = RelationshipNT.getObjectClass();
if (null != RelationshipOC)
{
ParentObject["objectclassid"] = RelationshipOC.ObjectClassId;
allowAdd = (RelationshipOC.CanAdd &&
_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, RelationshipNT));
}
}
}
else if (RelationshipType == CswEnumNbtViewPropIdType.ObjectClassPropId)
{
CswNbtMetaDataObjectClassProp RelationshipOCP = _CswNbtResources.MetaData.getObjectClassProp(RelationshipId);
CswNbtMetaDataObjectClass RelationshipOC = RelationshipOCP.getObjectClass();
if (null != RelationshipOC)
{
ParentObject["objectclassid"] = RelationshipOC.ObjectClassId;
allowAdd = RelationshipOC.CanAdd;
if (allowAdd)
{
foreach (CswNbtMetaDataNodeType NodeType in RelationshipOC.getLatestVersionNodeTypes())
{
allowAdd = _CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, NodeType);
if (allowAdd)
{
break;
}
}
}
}
}
ParentObject["allowadd"] = allowAdd;
JArray JOptions = new JArray();
ParentObject["options"] = JOptions;
ParentObject["relatednodeid"] = string.Empty;
ParentObject["relatednodename"] = string.Empty;
Dictionary <CswPrimaryKey, string> Options = _getOptions();
CswPrimaryKey SelectedNodeId = null;
if (null != SetSelected)
{
SelectedNodeId = SetSelected();
}
bool first = true;
foreach (CswPrimaryKey NodePk in Options.Keys)
{
if (first || (null != NodePk && NodePk == SelectedNodeId))
{
// Choose first option by default
ParentObject["relatednodeid"] = NodePk.ToString();
ParentObject["relatednodename"] = Options[NodePk];
first = false;
}
if (NodePk != null && NodePk.PrimaryKey != Int32.MinValue)
{
JObject JOption = new JObject();
JOption["id"] = NodePk.ToString();
JOption["value"] = Options[NodePk];
JOptions.Add(JOption);
}
}
} // ToJson()
/// <summary>
/// Create a dictionary of the unique key values of related nodes
/// As a side effect, also populate MergeInfoData.NodePair.NodeReferences
/// </summary>
private Dictionary <CswDelimitedString, CswPrimaryKey> _getUniqueKeysDict(MergeInfoData.MergeInfoNodePair NodePair, CswNbtNode Node, CswNbtMetaDataNodeTypeProp NodeReferenceProp)
{
Dictionary <CswDelimitedString, CswPrimaryKey> ret = new Dictionary <CswDelimitedString, CswPrimaryKey>();
char delimiter = '|';
// Find unique properties for this reference's nodetype
IEnumerable <CswNbtMetaDataNodeTypeProp> UniqueProps = NodeReferenceProp.getNodeType().getUniqueProps();
// Create a view of nodes that point to the target node via this reference
CswNbtView view = new CswNbtView(_CswNbtResources);
CswNbtViewRelationship rel1 = view.AddViewRelationship(Node.getNodeType(), false);
rel1.NodeIdsToFilterIn.Add(Node.NodeId);
CswNbtViewRelationship rel2 = view.AddViewRelationship(rel1, CswEnumNbtViewPropOwnerType.Second, NodeReferenceProp, false);
foreach (CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps)
{
view.AddViewProperty(rel2, uniqueProp);
}
// Iterate children and store unique property values in a dictionary key
ICswNbtTree tree = _CswNbtResources.Trees.getTreeFromView(view, RequireViewPermissions: false, IncludeHiddenNodes: true, IncludeSystemNodes: true);
if (tree.getChildNodeCount() > 0)
{
tree.goToNthChild(0);
for (Int32 c = 0; c < tree.getChildNodeCount(); c++)
{
tree.goToNthChild(c);
CswPrimaryKey thisNodeId = tree.getNodeIdForCurrentPosition();
// Populate MergeInfoData.NodePair.NodeReferences while we're here
NodePair.NodeReferences.Add(new MergeInfoData.MergeInfoNodeReference()
{
NodeId = thisNodeId.ToString(),
NodeTypePropId = NodeReferenceProp.PropId
});
CswDelimitedString key;
if (_AllUniqueKeys.ContainsKey(thisNodeId))
{
// If we've seen this node before, use the existing key but override the merge property
// (this will allow us to merge correctly if a nodetype has
// multiple compound unique references that are all involved in the merge)
key = _AllUniqueKeys[thisNodeId];
for (Int32 u = 0; u < UniqueProps.Count(); u++)
{
if (UniqueProps.ElementAt(u).PropId == NodeReferenceProp.PropId)
{
// This value will be equal after the merge
key[u] = "[mergeresult]";
}
} // foreach( CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps )
} // if( _AllUniqueKeys.ContainsKey( thisNodeId ) )
else
{
// generate a new key
key = new CswDelimitedString(delimiter);
foreach (CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps)
{
CswNbtTreeNodeProp prop = tree.getChildNodePropsOfNode().FirstOrDefault(p => p.NodeTypePropId == uniqueProp.PropId);
if (null != prop)
{
if (prop.NodeTypePropId == NodeReferenceProp.PropId)
{
// This value will be equal after the merge
key.Add("[mergeresult]");
}
else
{
key.Add(prop.Gestalt);
}
}
else
{
key.Add("");
}
} // foreach( CswNbtMetaDataNodeTypeProp uniqueProp in UniqueProps )
} // if-else( _AllUniqueKeys.ContainsKey( thisNodeId ) )
if (key.Count > 0)
{
ret.Add(key, thisNodeId);
_AllUniqueKeys[thisNodeId] = key;
}
tree.goToParentNode();
} // for( Int32 c = 0; c < tree.getChildNodeCount(); c++ )
} // if( tree.getChildNodeCount() > 0 )
return(ret);
} // _getUniqueKeysDict()
/// <summary>
/// Sets up the Add menu and the Edit View menu item
/// </summary>
void CswMainMenu_DataBinding(object sender, EventArgs e)
{
try
{
EnsureChildControls();
if (BatchEnabled)
{
_BatchOpsMenuItem.Text = "Single-Edit";
}
else
{
_BatchOpsMenuItem.Text = "Multi-Edit";
}
// Setup Export Menu
ExportMenuItem.Visible = false;
if (AllowExport)
{
if (_View != null)
{
ExportMenuItem.Visible = true;
ExportMenuItem.Items.Clear();
if (CswEnumNbtViewRenderingMode.Grid == NbtViewRenderingMode)
{
foreach (ExportOutputFormat FormatType in Enum.GetValues(typeof(ExportOutputFormat)))
{
if (ExportOutputFormat.MobileXML != FormatType || _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SI))
{
_addExportMenuItem(_View, FormatType, NbtViewRenderingMode);
}
}
}
else // tree or list
{
_addExportMenuItem(_View, ExportOutputFormat.ReportXML, NbtViewRenderingMode);
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SI))
{
_addExportMenuItem(_View, ExportOutputFormat.MobileXML, NbtViewRenderingMode);
}
}
}
else if (IsDesignMode && _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SI))
{
ExportMenuItem.Visible = false;
CswNbtMetaDataNodeType NodeType = null;
switch (DesignSelectedType)
{
case CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType:
NodeType = _CswNbtResources.MetaData.getNodeType(Convert.ToInt32(DesignSelectedValue));
break;
case CswNodeTypeTree.NodeTypeTreeSelectedType.Property:
CswNbtMetaDataNodeTypeProp NodeTypeProp = _CswNbtResources.MetaData.getNodeTypeProp(Convert.ToInt32(DesignSelectedValue));
NodeType = NodeTypeProp.getNodeType();
break;
case CswNodeTypeTree.NodeTypeTreeSelectedType.Tab:
CswNbtMetaDataNodeTypeTab NodeTypeTab = _CswNbtResources.MetaData.getNodeTypeTab(Convert.ToInt32(DesignSelectedValue));
NodeType = NodeTypeTab.getNodeType();
break;
}
ExportMenuItem.Visible = true;
ExportMenuItem.Items.Clear();
if (NodeType != null)
{
RadMenuItem DesignExportItem = new RadMenuItem();
DesignExportItem.Text = "Export NodeType XML";
DesignExportItem.Value = "export_" + ExportOutputFormat.MobileXML.ToString().ToLower();
DesignExportItem.CssClass = SubMenuGroupCssClass;
DesignExportItem.Attributes.Add("onclick", "openExportPopup('nodetypeid=" + NodeType.NodeTypeId.ToString() + "&format=" + ExportOutputFormat.MobileXML.ToString().ToLower() + "&renderingmode=" + NbtViewRenderingMode.ToString() + "');");
ExportMenuItem.Items.Add(DesignExportItem);
}
}
} // if( AllowExport )
if (AllowMobile && _View != null && _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SI))
{
_MobileMenuItem.Visible = true;
_MobileMenuItem.Items.Clear();
RadMenuItem MobileExportItem = new RadMenuItem();
MobileExportItem.Text = "Export Mobile XML";
MobileExportItem.Value = "export_" + ExportOutputFormat.MobileXML.ToString().ToLower();
MobileExportItem.CssClass = SubMenuGroupCssClass;
MobileExportItem.Attributes.Add("onclick", "openExportPopup('sessionviewid=" + _View.SessionViewId + "&format=" + ExportOutputFormat.MobileXML.ToString().ToLower() + "&renderingmode=" + NbtViewRenderingMode.ToString() + "');");
_MobileMenuItem.Items.Add(MobileExportItem);
}
else
{
_MobileMenuItem.Visible = false;
}
// Setup Add Menu
_AddMenuItem.Visible = false;
if (ParentNodeKey != null)
{
if (ParentNodeKey.NodeSpecies == CswEnumNbtNodeSpecies.Plain)
{
_Node = _CswNbtResources.Nodes[ParentNodeKey];
}
if (AllowAdd)
{
if (ParentNodeKeyViewNode != null)
{
bool LimitToFirstGeneration = (View.ViewMode == CswEnumNbtViewRenderingMode.Grid);
Collection <CswNbtViewNode.CswNbtViewAddNodeTypeEntry> AllowedChildNodeTypes = ParentNodeKeyViewNode.AllowedChildNodeTypes(LimitToFirstGeneration);
if (AllowedChildNodeTypes.Count > 0)
{
_AddMenuItem.Visible = true;
_AddMenuItem.Items.Clear();
string AddMenuDoesntChangeViewString = "0";
if (AddMenuDoesntChangeView)
{
AddMenuDoesntChangeViewString = "1";
}
string AddMenuDoesntChangeSelectedNodeString = "0";
if (AddMenuDoesntChangeSelectedNode)
{
AddMenuDoesntChangeSelectedNodeString = "1";
}
foreach (CswNbtViewNode.CswNbtViewAddNodeTypeEntry Entry in AllowedChildNodeTypes)
{
RadMenuItem TypeMenuItem = new RadMenuItem();
TypeMenuItem.Text = Entry.NodeType.NodeTypeName;
TypeMenuItem.Value = "addnode_" + Entry.NodeType.NodeTypeId.ToString();
TypeMenuItem.CssClass = SubMenuGroupCssClass;
//TypeMenuItem.Attributes.Add( "onclick", "openNewNodePopup('" + Entry.NodeType.NodeTypeId.ToString() + "', '" + ParentNodeKey.ToJavaScriptParam() + "', '" + ParentNodeKeyViewNode.View.SessionViewId.ToString() + "', '" + Entry.ViewRelationship.UniqueId + "', '" + AddMenuDoesntChangeViewString + "', '" + AddMenuDoesntChangeSelectedNodeString + "');" );
// Case 20544 - Add viewid to querystring
TypeMenuItem.Attributes.Add("onclick", "openNewNodePopup('" + Entry.NodeType.NodeTypeId.ToString() + "', '" + ParentNodeKey.ToString() + "', '" + ParentNodeKeyViewNode.View.SessionViewId.ToString() + "', '" + AddMenuDoesntChangeViewString + "', '" + AddMenuDoesntChangeSelectedNodeString + "', '" + _View.ViewId.ToString() + "');");
_AddMenuItem.Items.Add(TypeMenuItem);
}
}
}
}
}
else if (IsDesignMode)
{
_AddMenuItem.Items.Clear();
if (DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.Property ||
DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.NodeTypeBaseVersion ||
DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.PropertyFilter)
{
// No Add Menu
}
else if (DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.Tab)
{
CswNbtMetaDataNodeTypeTab SelectedTab = CswNbtResources.MetaData.getNodeTypeTab(Convert.ToInt32(DesignSelectedValue));
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, SelectedTab.getNodeType()))
{
if (SelectedTab.getNodeType().IsLatestVersion())
{
_AddMenuItem.Visible = true;
RadMenuItem AddPropMenuItem = new RadMenuItem();
if (DesignMode == NbtDesignMode.Inspection)
{
AddPropMenuItem.Text = "Question";
}
else
{
AddPropMenuItem.Text = "Property";
}
AddPropMenuItem.Value = "addprop_" + DesignSelectedValue;
AddPropMenuItem.CssClass = SubMenuGroupCssClass;
string js = string.Empty;
if (DesignMode == NbtDesignMode.Inspection)
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.Property + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Tab + "','" + DesignSelectedValue + "', 'i');";
}
else
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.Property + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Tab + "','" + DesignSelectedValue + "', '');";
}
AddPropMenuItem.Attributes.Add("onclick", js);
AddPropMenuItem.PostBack = false;
_AddMenuItem.Items.Add(AddPropMenuItem);
}
}
}
else if (DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType)
{
CswNbtMetaDataNodeType SelectedNodeType = CswNbtResources.MetaData.getNodeType(Convert.ToInt32(DesignSelectedValue));
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, SelectedNodeType))
{
if (SelectedNodeType != null && SelectedNodeType.IsLatestVersion())
{
_AddMenuItem.Visible = true;
RadMenuItem AddTabMenuItem = new RadMenuItem();
if (DesignMode == NbtDesignMode.Inspection)
{
AddTabMenuItem.Text = "Section";
}
else
{
AddTabMenuItem.Text = "Tab";
}
AddTabMenuItem.Value = "addtab_" + DesignSelectedValue;
AddTabMenuItem.CssClass = SubMenuGroupCssClass;
string js = string.Empty;
if (DesignMode == NbtDesignMode.Inspection)
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.Tab + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType + "','" + DesignSelectedValue + "', 'i');";
}
else
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.Tab + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType + "','" + DesignSelectedValue + "', '');";
}
AddTabMenuItem.Attributes.Add("onclick", js);
AddTabMenuItem.PostBack = false;
_AddMenuItem.Items.Add(AddTabMenuItem);
}
}
}
else
{
_AddMenuItem.Visible = true;
RadMenuItem AddTypeMenuItem = new RadMenuItem();
if (DesignMode == NbtDesignMode.Inspection)
{
AddTypeMenuItem.Text = "Inspection Design";
}
else
{
AddTypeMenuItem.Text = "NodeType";
}
AddTypeMenuItem.Value = "addtype";
AddTypeMenuItem.CssClass = SubMenuGroupCssClass;
string js = string.Empty;
if (DesignSelectedType == CswNodeTypeTree.NodeTypeTreeSelectedType.Category)
{
if (DesignMode == NbtDesignMode.Inspection)
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType.ToString() + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Category.ToString() + "','" + DesignSelectedValue + "', 'i');";
}
else
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType.ToString() + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Category.ToString() + "','" + DesignSelectedValue + "', '');";
}
}
else
{
if (DesignMode == NbtDesignMode.Inspection)
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType.ToString() + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Root.ToString() + "','', 'i');";
}
else
{
js = "openDesignAddPopup('" + CswNodeTypeTree.NodeTypeTreeSelectedType.NodeType.ToString() + "','" + CswNodeTypeTree.NodeTypeTreeSelectedType.Root.ToString() + "','', '');";
}
}
AddTypeMenuItem.Attributes.Add("onclick", js);
AddTypeMenuItem.PostBack = false;
_AddMenuItem.Items.Add(AddTypeMenuItem);
}
}
// Edit View
if (AllowEditView && _EditViewMenuItem != null && View != null)
{
_EditViewMenuItem.NavigateUrl = "EditView.aspx?viewid=" + View.ViewId.ToString();
if (View.Visibility == CswEnumNbtViewVisibility.Property ||
View.Visibility == CswEnumNbtViewVisibility.Hidden)
{
_EditViewMenuItem.NavigateUrl += "&step=2";
}
}
else
{
_EditViewMenuItem.NavigateUrl = "EditView.aspx";
}
// Search
//if( View is CswNbtView && View != null && View.IsSearchable() )
//{
_SearchMenuItem.Visible = true;
// Handle searching from grid properties:
if (View != null && ParentNodeKey != null)
{
// Case 20715 - need to check NodeSpecies first
if (ParentNodeKey.NodeSpecies == CswEnumNbtNodeSpecies.Plain && null != ParentNodeKey.NodeId)
{
_SearchMenuItem.NavigateUrl = "Search.aspx?nodeid=" + ParentNodeKey.NodeId.ToString() + "&viewid=" + View.ViewId.ToString();
}
else
{
_SearchMenuItem.NavigateUrl = "Search.aspx?nodeid=" + "&viewid=" + View.ViewId.ToString();
}
}
else
{
_SearchMenuItem.NavigateUrl = "Search.aspx";
}
//}
//else
//{
// _SearchMenuItem.Visible = false;
//}
// Copy
if (AllowCopy && SelectedNodeKey != null &&
SelectedNodeKey.NodeSpecies == CswEnumNbtNodeSpecies.Plain &&
_CswNbtResources.Permit.canNodeType(Nbt.Security.CswEnumNbtNodeTypePermission.Create, _CswNbtResources.MetaData.getNodeType(SelectedNodeKey.NodeTypeId)))
{
if (SelectedNodeKeyViewNode != null && SelectedNodeKeyViewNode is CswNbtViewRelationship &&
((CswNbtViewRelationship)SelectedNodeKeyViewNode).NodeIdsToFilterIn.Count == 0) // BZ 8022
{
CswNbtMetaDataNodeType CopyNodeType = _CswNbtResources.MetaData.getNodeType(SelectedNodeKey.NodeTypeId);
string badproperty = string.Empty;
if (!CopyNodeType.IsUniqueAndRequired(ref badproperty))
{
_CopyMenuItem.Visible = true;
_CopyMenuItem.Attributes.Add("onclick", "openCopyPopup('" + SelectedNodeKey.ToString() + "');");
}
}
}
}
catch (Exception ex)
{
HandleError(ex);
}
} // CswMainMenu_DataBinding()
