public static bool InvalidColumnValue(
object fieldValue, Enums.Operator op,
string valueToCompare, Type fieldValueType)
{
return(ConditionEvaluator.MatchItemValueBasedOnOperatorAndValueType(
op, valueToCompare, fieldValue, fieldValueType));
}
public static bool Check(string userName, Enums.Operator op)
{
if (string.IsNullOrEmpty(userName) ||
userName.Equals(Constants.AllSPPrinciples,
StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
if (userName.Contains("\\"))
{
switch (op)
{
// TODO: why In and Equal have same implementation?
case Enums.Operator.In:
return(userName.ToLower() == SPContext.Current.Web.CurrentUser.LoginName.ToLower());
case Enums.Operator.Equal:
return(userName.ToLower() == SPContext.Current.Web.CurrentUser.LoginName.ToLower());
case Enums.Operator.NotEqual:
return(userName.ToLower() != SPContext.Current.Web.CurrentUser.LoginName.ToLower());
case Enums.Operator.NotIn:
return(userName.ToLower() != SPContext.Current.Web.CurrentUser.LoginName.ToLower());
default:
return(true);
}
}
else
{
if (SPContext.Current.Web.Groups.OfType <SPGroup>().
Count(g => g.Name.Equals(userName,
StringComparison.InvariantCultureIgnoreCase)) <= 0)
{
return(false);
}
SPGroup grp = SPContext.Current.Web.Groups[userName];
switch (op)
{
case Enums.Operator.In:
return(grp.ContainsCurrentUser);
case Enums.Operator.Equal:
return(grp.ContainsCurrentUser);
case Enums.Operator.NotIn:
return(!grp.ContainsCurrentUser);
case Enums.Operator.NotEqual:
return(!grp.ContainsCurrentUser);
default:
return(true);
}
}
}
public static bool InvalidLengthValue(int length, Enums.Operator op,
string lengthToCompare)
{
int intlengthToCompare;
if (int.TryParse(lengthToCompare, out intlengthToCompare))
{
switch (op)
{
case Enums.Operator.Equal:
return(length == intlengthToCompare);
case Enums.Operator.NotEqual:
return(length != intlengthToCompare);;
case Enums.Operator.GreaterThan:
return(length > intlengthToCompare);
case Enums.Operator.LessThan:
return(length < intlengthToCompare);
default:
return(false);
}
}
else
{
return(true);
}
}
public FieldDefault(Field onField, string forSPPrinciples,
Enums.Operator bySPPrinciplesOperator, string spContentType, object value)
{
this.OnField = onField;
this.ForSPPrinciples = forSPPrinciples;
this.BySPPrinciplesOperator = bySPPrinciplesOperator;
this.SPContentType = spContentType;
this.Value = value;
}
public PermissionBase(Enums.PermissionLevel level, List <Enums.SPForms> onForms,
string forSPPrinciples, Enums.Operator bySPPrinciplesOperator)
{
this.Level = level;
this.OnForms = onForms;
this.ForSPPrinciples = forSPPrinciples;
this.BySPPrinciplesOperator = bySPPrinciplesOperator;
this.Conditions = new Conditions();
}
public FieldValidation(Field onField, Enums.ValidationRule rule, Enums.Operator byRuleOperator, object value, string errorMsg, string forSPPrinciples, Enums.Operator bySPPrinciplesOperator)
{
this.OnField = onField;
this.Rule = rule;
this.ByRuleOperator = byRuleOperator;
this.Value = value;
this.ErrorMsg = errorMsg;
this.ForSPPrinciples = forSPPrinciples;
this.BySPPrinciplesOperator = bySPPrinciplesOperator;
this.Conditions = new Conditions();
}
//TODO: check the values based on column type for below types..
private static bool CheckFromListItem(string fieldName,
Enums.Operator op, string value)
{
if (SPContext.Current.List.Fields.ContainsField(fieldName))
{
object fieldValue = SPContext.Current.ListItem[fieldName];
Type fieldValueType =
SPContext.Current.List.Fields.GetFieldByInternalName(fieldName).
FieldValueType;
return(MatchItemValueBasedOnOperatorAndValueType(op, value,
fieldValue, fieldValueType));
}
else
{
return(true);
}
}
private static bool CheckFromUIValue(string fieldName, Enums.Operator op, string value, SPFormContext formContext, string clientID)
{
BaseFieldControl field = ValidationInjector.GetFieldControlByName(fieldName, formContext, clientID);
// to manage the rich field UI text
if (field is RichTextField)
{
string fieldVaue = ((RichTextField)field).HiddenInput.Value;
switch (op)
{
case Enums.Operator.Equal:
return(fieldVaue.Equals(value));
case Enums.Operator.NotEqual:
return(!fieldVaue.Equals(value));
case Enums.Operator.Contains:
return(fieldVaue.Contains(value));
case Enums.Operator.NotContains:
return(!fieldVaue.Contains(value));
default:
return(false);
}
}
else
{
if (field is LookupField)
{
LookupField l = field as LookupField;
String v = l.Value.ToString();
}
return(MatchItemValueBasedOnOperatorAndValueType(op, value, field.Value, field.Field.FieldValueType));
}
}
private static bool CompareValuesBasedOnOperator(string sourceValue,
Enums.Operator op, string targetValue)
{
sourceValue = sourceValue.Trim();
targetValue = targetValue.Trim();
switch (op)
{
case Enums.Operator.Equal:
return(sourceValue.Equals(targetValue, StringComparison.InvariantCultureIgnoreCase));
case Enums.Operator.NotEqual:
return(!sourceValue.Equals(targetValue, StringComparison.InvariantCultureIgnoreCase));
case Enums.Operator.Contains:
return(sourceValue.IndexOf(targetValue, StringComparison.InvariantCultureIgnoreCase) > -1);
case Enums.Operator.NotContains:
return(!(sourceValue.IndexOf(targetValue, StringComparison.InvariantCultureIgnoreCase) > -1));
default:
return(false);
}
}
public static bool MatchItemValueBasedOnOperatorAndValueType(Enums.Operator op, string value, object fieldValue, Type fieldValueType)
{
if (fieldValue != null && !string.IsNullOrEmpty(fieldValue.ToString()))
{
if (fieldValueType == (typeof(SPFieldUrlValue)))
{
SPFieldUrlValue fieldUrlValue = new SPFieldUrlValue(fieldValue.ToString());
bool isDescMatched = CompareValuesBasedOnOperator(fieldUrlValue.Description, op, value);
bool isUrlMatched = CompareValuesBasedOnOperator(fieldUrlValue.Url, op, value);
return(isDescMatched || isUrlMatched);
}
else if (fieldValueType == (typeof(SPFieldUserValue)))
{
SPFieldUserValue fieldUserValue = new SPFieldUserValue(SPContext.Current.Web, fieldValue.ToString());
string userLoginName = fieldUserValue.User.LoginName;
string userDispalyName = fieldUserValue.User.Name;
bool isLoginMatched = CompareValuesBasedOnOperator(userLoginName, op, value);
bool isDisplayNameMatched = CompareValuesBasedOnOperator(userLoginName, op, value);
return(isLoginMatched || isDisplayNameMatched);
}
else if (fieldValueType == (typeof(SPFieldUserValueCollection)))
{
SPFieldUserValueCollection fieldUserValueCollection = new SPFieldUserValueCollection(SPContext.Current.Web, fieldValue.ToString());
string userLoginNames = "";
string userDispalyNames = "";
foreach (SPFieldUserValue userValue in fieldUserValueCollection)
{
userLoginNames += userValue.LookupValue + Constants.ValueCollectionSeparator;
if (userValue.User != null)
{
userDispalyNames += userValue.User.Name + Constants.ValueCollectionSeparator;
}
}
userLoginNames = userLoginNames.TrimEnd(Constants.ValueCollectionSeparator.ToCharArray());
userDispalyNames = userDispalyNames.TrimEnd(Constants.ValueCollectionSeparator.ToCharArray());
bool isLoginMatched = CompareValuesBasedOnOperator(userLoginNames, op, value);
bool isDisplayNameMatched = CompareValuesBasedOnOperator(userLoginNames, op, value);
return(isLoginMatched || isDisplayNameMatched);
}
else if (fieldValueType == (typeof(SPFieldLookupValue)))
{
SPFieldLookupValue fieldLookupValue = new SPFieldLookupValue(fieldValue.ToString());
string strFieldValue = fieldLookupValue.LookupValue;
return(CompareValuesBasedOnOperator(strFieldValue, op, value));
}
else if (fieldValueType == (typeof(SPFieldLookupValueCollection)))
{
SPFieldLookupValueCollection fieldLookupValueCollection = new SPFieldLookupValueCollection(fieldValue.ToString());
string strFieldValue = "";
foreach (SPFieldLookupValue lookup in fieldLookupValueCollection)
{
strFieldValue += lookup.LookupValue + Constants.ValueCollectionSeparator;
}
strFieldValue = strFieldValue.TrimEnd(Constants.ValueCollectionSeparator.ToCharArray());
return(CompareValuesBasedOnOperator(strFieldValue, op, value));
}
else if (fieldValueType == (typeof(DateTime)))
{
DateTime sourceDT = DateTime.Parse(fieldValue.ToString());
DateTime targetDT = new DateTime();
if (DateTime.TryParse(value, out targetDT))
{
switch (op)
{
case Enums.Operator.Equal:
return(sourceDT == targetDT);
case Enums.Operator.NotEqual:
return(sourceDT != targetDT);
case Enums.Operator.GreaterThan:
return(sourceDT > targetDT);
case Enums.Operator.GreaterThanOrEqual:
return(sourceDT >= targetDT);
case Enums.Operator.LessThan:
return(sourceDT < targetDT);
case Enums.Operator.LessThanOrEqual:
return(sourceDT <= targetDT);
default:
return(false);
}
}
else
{
return(false);
}
}
else if (fieldValueType == (typeof(int)))
{
int sourceInt = int.Parse(fieldValue.ToString());
int targetInt;
if (Int32.TryParse(value, out targetInt))
{
switch (op)
{
case Enums.Operator.Equal:
return(sourceInt == targetInt);
case Enums.Operator.NotEqual:
return(sourceInt != targetInt);
case Enums.Operator.GreaterThan:
return(sourceInt > targetInt);
case Enums.Operator.GreaterThanOrEqual:
return(sourceInt >= targetInt);
case Enums.Operator.LessThan:
return(sourceInt < targetInt);
case Enums.Operator.LessThanOrEqual:
return(sourceInt <= targetInt);
default:
return(false);
}
}
else
{
return(false);
}
}
else if (fieldValueType == (typeof(Boolean)))
{
bool sourceBool = Boolean.Parse(fieldValue.ToString());
bool targetBool = false;
if (value.Equals("True", StringComparison.InvariantCultureIgnoreCase) || value.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
targetBool = true;
}
else if (value.Equals("False", StringComparison.InvariantCultureIgnoreCase) || value.Equals("No", StringComparison.InvariantCultureIgnoreCase))
{
targetBool = false;
}
else
{
return(false);
}
switch (op)
{
case Enums.Operator.Equal:
return(sourceBool == targetBool);
case Enums.Operator.NotEqual:
return(sourceBool != targetBool);
case Enums.Operator.Contains:
return(sourceBool == targetBool);
case Enums.Operator.NotContains:
return(sourceBool != targetBool);
default:
return(false);
}
}
else // default matching will be performed with string type
{
string strFieldValue = fieldValue.ToString();
return(CompareValuesBasedOnOperator(strFieldValue, op, value));
}
}
else
{
return(false);
}
}
public TabPermission(bool isDefault, Enums.PermissionLevel level,
List <Enums.SPForms> onForms, string forSPPrinciples, Enums.Operator bySPPrinciplesOperator)
: base(level, onForms, forSPPrinciples, bySPPrinciplesOperator)
{
this.IsDefault = isDefault;
}
public FieldPermission(Field OnField, Enums.PermissionLevel level, List <Enums.SPForms> onForms, string forSPPrinciples, Enums.Operator bySPPrinciplesOperator)
: base(level, onForms, forSPPrinciples, bySPPrinciplesOperator)
{
this.OnField = OnField;
}
protected void createTabXML()
{
bool isDefault = false;
Tabs allTabs = new Tabs();
DataTable tabsDataTable = TabDataTable;
DataTable permissionDataTable = TabPermissionDataTable;
DataTable permissionConditionDataTable = PermissionConditionDataTable;
foreach (DataRow drTab in tabsDataTable.Rows)
{
ushort index = Convert.ToUInt16(drTab[Constants.TabField.Index]);
string title = drTab[Constants.TabField.Title].ToString();
string desc = drTab[Constants.TabField.Description].ToString();
bool isTabDefault = Helper.ConvertToBool(drTab[Constants.TabField.IsDefault].ToString());
int tabID = Convert.ToInt32(drTab[Constants.RowID]);
Tab t1 = new Tab(index, title, desc);
t1.CommaSeperatedFields = drTab[Constants.TabField.FieldToString].ToString();
t1.IsSelected = isTabDefault;
DataTable permissionOfSelectedTab = Helper.GetViewFromDataTable(permissionDataTable, tabID, Constants.PermissionField.TabRowID).ToTable();
if (permissionOfSelectedTab != null && permissionOfSelectedTab.Rows.Count > 0)
{
foreach (DataRow drPermission in permissionOfSelectedTab.Rows)
{
bool IsDefault = Helper.ConvertToBool(drPermission[Constants.PermissionField.IsDefault].ToString());
Enums.PermissionLevel permissionLevel = (Enums.PermissionLevel)(Convert.ToInt32(drPermission[Constants.PermissionField.PermissionID].ToString()));
string OnForms = drPermission[Constants.PermissionField.OnFormIDs].ToString();
string ForSPPrinciples = drPermission[Constants.PermissionField.SPPrinciples].ToString();
Enums.Operator BySPPrinciplesOperator = (Enums.Operator)(Convert.ToInt32(drPermission[Constants.PermissionField.SPPrinciplesOperatorID].ToString()));
int permissionID = Convert.ToInt32(drPermission[Constants.RowID]);
TabPermission perm1 = new TabPermission(isDefault, permissionLevel, TabPermission.ParseForms(OnForms), ForSPPrinciples, BySPPrinciplesOperator);
DataTable conditionOfSelectedPermission = Helper.GetViewFromDataTable(permissionConditionDataTable, permissionID, Constants.ConditionField.PermissionRowID).ToTable();
if (conditionOfSelectedPermission != null && conditionOfSelectedPermission.Rows.Count > 0)
{
foreach (DataRow drCondition in conditionOfSelectedPermission.Rows)
{
string OnField = drCondition[Constants.ConditionField.SPFieldName].ToString();
Enums.Operator ByFieldOperator = (Enums.Operator)Convert.ToInt32(drCondition[Constants.ConditionField.SPFieldOperatorID].ToString());
object Value = drCondition[Constants.ConditionField.Value].ToString();
perm1.Conditions.Add(new Condition(new Field(OnField), ByFieldOperator, Value));
}
}
t1.Permissions.Add(perm1);
}
}
allTabs.Add(t1);
}
SPSecurity.RunWithElevatedPrivileges(delegate
{
using (SPSite objSite = new SPSite(SPContext.Current.Web.Url.ToString()))
{
using (SPWeb objWeb = objSite.OpenWeb())
{
SPList list = objWeb.Lists[new Guid(Request.QueryString["List"])];
objWeb.AllowUnsafeUpdates = true;
string xml = allTabs.ToString();
if (allTabs.Count > 0 && Helper.IsValidXml(xml))
{
Helper.CreateConfigFile(list, Constants.ConfigFile.TabSettingFile, xml);
}
else
{
Helper.DeleteConfigFile(list, Constants.ConfigFile.TabSettingFile, xml);
}
objWeb.AllowUnsafeUpdates = false;
}
}
});
}
public Condition(Field onField, Enums.Operator byFieldOperator, object value)
{
this.OnField = onField;
this.ByFieldOperator = byFieldOperator;
this.Value = value;
}
protected void createTabXML()
{
FieldPermissions allFieldPermissions = new FieldPermissions();
DataTable permissionDataTable = TabPermissionDataTable;
DataTable permissionConditionDataTable = PermissionConditionDataTable;
foreach (DataRow drPermission in permissionDataTable.Rows)
{
string OnField = drPermission[Constants.PermissionField.SPFieldName].ToString();
bool IsDefault = Helper.ConvertToBool(drPermission[Constants.PermissionField.IsDefault].ToString());
Enums.PermissionLevel permissionLevel = (Enums.PermissionLevel)(Convert.ToInt32(drPermission[Constants.PermissionField.PermissionID].ToString()));
string OnForms = drPermission[Constants.PermissionField.OnFormIDs].ToString();
string ForSPPrinciples = drPermission[Constants.PermissionField.SPPrinciples].ToString();
Enums.Operator BySPPrinciplesOperator = (Enums.Operator)(Convert.ToInt32(drPermission[Constants.PermissionField.SPPrinciplesOperatorID].ToString()));
int permissionID = Convert.ToInt32(drPermission[Constants.RowID]);
FieldPermission perm1 = new FieldPermission(new Field(OnField), permissionLevel, FieldPermission.ParseForms(OnForms), ForSPPrinciples, BySPPrinciplesOperator);
DataTable conditionOfSelectedPermission = Helper.GetViewFromDataTable(permissionConditionDataTable, permissionID, Constants.ConditionField.PermissionRowID).ToTable();
if (conditionOfSelectedPermission != null && conditionOfSelectedPermission.Rows.Count > 0)
{
foreach (DataRow drCondition in conditionOfSelectedPermission.Rows)
{
string OnField2 = drCondition[Constants.ConditionField.SPFieldName].ToString();
Enums.Operator ByFieldOperator = (Enums.Operator)Convert.ToInt32(drCondition[Constants.ConditionField.SPFieldOperatorID].ToString());
object Value = drCondition[Constants.ConditionField.Value].ToString();
perm1.Conditions.Add(new Condition(new Field(OnField2), ByFieldOperator, Value));
}
}
allFieldPermissions.Add(perm1);
}
SPSecurity.RunWithElevatedPrivileges(delegate
{
using (SPSite objSite = new SPSite(SPContext.Current.Web.Url.ToString()))
{
using (SPWeb objWeb = objSite.OpenWeb())
{
SPList list = objWeb.Lists[new Guid(Request.QueryString["List"])];
objWeb.AllowUnsafeUpdates = true;
string xml = allFieldPermissions.ToString();
if (allFieldPermissions.Count > 0 && Helper.IsValidXml(xml))
{
Helper.CreateConfigFile(list, Constants.ConfigFile.FieldPermissionFile, xml);
}
else
{
Helper.DeleteConfigFile(list, Constants.ConfigFile.FieldPermissionFile, xml);
}
objWeb.AllowUnsafeUpdates = false;
}
}
});
}
protected void createTabXML()
{
FieldValidations allFieldsValidations = new FieldValidations();
DataTable validationDataTable = ValidationDataTable;
DataTable validationConditionDataTable = ValidationConditionDataTable;
foreach (DataRow drValidationRow in validationDataTable.Rows)
{
string FieldName = drValidationRow[Constants.ValidationField.SPFieldName].ToString();
Enums.ValidationRule ValidationRule = (Enums.ValidationRule)(Convert.ToInt32(drValidationRow[Constants.ValidationField.ValidationRuleID].ToString()));
Enums.Operator FieldOperatorID = (Enums.Operator)(Convert.ToInt32(drValidationRow[Constants.ValidationField.SPFieldOperatorID].ToString()));
string ValidationValue = drValidationRow[Constants.ValidationField.Value].ToString();
string ErrorMessage = drValidationRow[Constants.ValidationField.ErrorMessage].ToString();
Enums.Operator BySPPrincipalOperator = (Enums.Operator)(Convert.ToInt32(drValidationRow[Constants.ValidationField.SPPrinciplesOperatorID].ToString()));
string ForSPPrinciples = drValidationRow[Constants.ValidationField.SPPrinciples].ToString();
FieldValidation objValidation = new FieldValidation(new Field(FieldName), ValidationRule, FieldOperatorID, ValidationValue, ErrorMessage, ForSPPrinciples, BySPPrincipalOperator);
int validationID = Convert.ToInt32(drValidationRow[Constants.RowID]);
DataTable conditionOfSelectedValidation = Helper.GetViewFromDataTable(validationConditionDataTable, validationID, Constants.ConditionField.ValidationRowID).ToTable();
if (conditionOfSelectedValidation != null && conditionOfSelectedValidation.Rows.Count > 0)
{
foreach (DataRow drCondition in conditionOfSelectedValidation.Rows)
{
string OnField2 = drCondition[Constants.ConditionField.SPFieldName].ToString();
Enums.Operator ByFieldOperator = (Enums.Operator)Convert.ToInt32(drCondition[Constants.ConditionField.SPFieldOperatorID].ToString());
object Value = drCondition[Constants.ConditionField.Value].ToString();
objValidation.Conditions.Add(new Condition(new Field(OnField2), ByFieldOperator, Value));
}
}
allFieldsValidations.Add(objValidation);
}
SPSecurity.RunWithElevatedPrivileges(delegate
{
using (SPSite objSite = new SPSite(SPContext.Current.Web.Url.ToString()))
{
using (SPWeb objWeb = objSite.OpenWeb())
{
SPList list = objWeb.Lists[new Guid(Request.QueryString["List"])];
objWeb.AllowUnsafeUpdates = true;
string xml = allFieldsValidations.ToString();
if (allFieldsValidations.Count > 0 && Helper.IsValidXml(xml))
{
Helper.CreateConfigFile(list, Constants.ConfigFile.FieldValidationFile, xml);
}
else
{
Helper.DeleteConfigFile(list, Constants.ConfigFile.FieldValidationFile, xml);
}
objWeb.AllowUnsafeUpdates = false;
}
}
});
}
