private string ProcessField(SPWeb web, SPListItem li, SPField field)
{
string val = "";
try
{
switch (field.Type)
{
case SPFieldType.DateTime:
DateTime dt = DateTime.Parse(li[field.Id].ToString());
//int localeID = (int)web.RegionalSettings.LocaleId;
System.Globalization.CultureInfo cInfo = new System.Globalization.CultureInfo(web.Locale.LCID);
IFormatProvider culture = new System.Globalization.CultureInfo(cInfo.Name, true);
if (getFieldSchemaAttribValue(field.SchemaXml, "Format").ToUpper() == "DATEONLY")
{
val = dt.ToUniversalTime().GetDateTimeFormats(culture)[0]; //dt.ToShortDateString();
}
else
{
val = dt.ToUniversalTime().GetDateTimeFormats(culture)[72]; //dt.ToShortDateString() + " " + dt.ToShortTimeString();
}
break;
case SPFieldType.Number:
val = "0";
try
{
val = li[field.Id].ToString();
if (((SPFieldNumber)field).ShowAsPercentage)
{
val = (double.Parse(val) * 100).ToString() + "%";
}
else
{
val = field.GetFieldValueAsText(val);
}
}
catch { }
break;
default:
val = field.GetFieldValueAsText(val);
break;
}
}
catch { }
return(val);
}
private DataTable GetListTable(string search, string groupName)
{
SPField searchField = list.Fields[new Guid(groupName)];
SPListItemCollection items = null;
if (!string.IsNullOrEmpty(search))
{
SPQuery query = new SPQuery();
if (searchField.Type == SPFieldType.DateTime)
{
search = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Parse(search));
}
string valueType = searchField.TypeAsString;
if (searchField.Type == SPFieldType.Calculated)
{
valueType = "Text";
}
query.ViewAttributes = "Scope=\"Recursive\"";
query.Query = string.Format("<Where><{0}><FieldRef ID=\"{1}\"/><Value Type=\"{2}\">{3}</Value></{0}></Where>"
, searchOperator ?? "Eq"
, searchField.Id.ToString()
, valueType
, search);
items = list.GetItems(query);
}
// return all items when search is blank?
//else
//{
// items = list.Items;
//}
if (items != null)
{
foreach (SPListItem item in items)
{
DataRow row = dataTable.NewRow();
foreach (DataColumn col in dataTable.Columns)
{
SPField field = item.Fields[new Guid(col.ColumnName)];
string sData = string.Empty;
try
{
sData = field.GetFieldValueAsText(item[field.Id]);
}
catch { }
row[col] = sData;
}
dataTable.Rows.Add(row);
}
}
return(dataTable);
}
private DataTable GetListTable(string search, string groupName)
{
SPField searchField = list.Fields[new Guid(groupName)];
SPListItemCollection items = null;
if (!string.IsNullOrEmpty(search))
{
SPQuery query = new SPQuery();
if (searchField.Type == SPFieldType.DateTime)
{
search = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Parse(search));
}
string valueType = searchField.TypeAsString;
if (searchField.Type == SPFieldType.Calculated)
{
valueType = "Text";
}
query.ViewAttributes = "Scope=\"Recursive\"";
query.Query = string.Format("<Where><{0}><FieldRef ID=\"{1}\"/><Value Type=\"{2}\">{3}</Value></{0}></Where>"
, searchOperator ?? "Eq"
, searchField.Id.ToString()
, valueType
, search);
items = list.GetItems(query);
}
else
{
items = list.Items;
}
if (items.Count > propertyBag.MaxSearchResults)
{
this.PickerDialog.ErrorMessage = LookupFieldWithPickerHelper.GetResourceString("lookupWithPickerSearchResultExceededMessage");
return(dataTable);
}
foreach (SPListItem item in items)
{
DataRow row = dataTable.NewRow();
foreach (DataColumn col in dataTable.Columns)
{
SPField field = item.Fields[new Guid(col.ColumnName)];
row[col] = field.GetFieldValueAsText(item[field.Id]);
}
dataTable.Rows.Add(row);
}
return(dataTable);
}
/// <summary>
/// Gets the field special values.
/// </summary>
/// <param name="spField">The sp field.</param>
/// <param name="stringValue">The string value.</param>
/// <param name="value">The value.</param>
/// <param name="fieldEditValue">The field edit value.</param>
/// <param name="fieldTextValue">The field text value.</param>
/// <param name="fieldHtmlValue">The field HTML value.</param>
private static void GetFieldSpecialValues(SPField spField, string stringValue, object value,
out string fieldEditValue,
out string fieldTextValue, out string fieldHtmlValue)
{
fieldTextValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueAsText(value) ?? string.Empty;
fieldHtmlValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueAsHtml(value) ?? string.Empty;
fieldEditValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueForEdit(value) ?? string.Empty;
}
private static string GetFieldValue(SPField oConditionField, SPListItem li)
{
var fieldValue = string.Empty;
if (oConditionField != null)
{
fieldValue = li[oConditionField.Id].ToString();
if (oConditionField.Type != SPFieldType.DateTime &&
oConditionField.Type != SPFieldType.Boolean &&
oConditionField.Type != SPFieldType.Number &&
oConditionField.Type != SPFieldType.Currency)
{
fieldValue = oConditionField.GetFieldValueAsText(fieldValue);
}
}
return(fieldValue);
}
/// <summary>
/// Gets the field special values.
/// </summary>
/// <param name="spField">The sp field.</param>
/// <param name="stringValue">The string value.</param>
/// <param name="value">The value.</param>
/// <param name="fieldEditValue">The field edit value.</param>
/// <param name="fieldTextValue">The field text value.</param>
/// <param name="fieldHtmlValue">The field HTML value.</param>
protected void GetFieldSpecialValues(SPField spField, string stringValue, object value,
out string fieldEditValue,
out string fieldTextValue, out string fieldHtmlValue)
{
if (spField.Type != SPFieldType.DateTime)
{
fieldTextValue = stringValue;
fieldEditValue = stringValue;
fieldHtmlValue = stringValue;
try
{
fieldTextValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueAsText(value) ?? string.Empty;
fieldEditValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueForEdit(value) ?? string.Empty;
fieldHtmlValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: spField.GetFieldValueAsHtml(value) ?? string.Empty;
}
catch
{
}
}
else
{
string specialValue = string.IsNullOrEmpty(stringValue)
? string.Empty
: ((DateTime)value).ToShortDateString();
fieldTextValue = specialValue;
fieldHtmlValue = specialValue;
fieldEditValue = specialValue;
}
}
internal static object ToEntityField(PropertyInfo prop, SPListItem listItem, SPField field = null,
object value = null, bool reloadLookupItem = true)
{
string propName = prop.Name;
Type propType = prop.PropertyType;
// var fieldAttrs = (FieldAttribute[])prop.GetCustomAttributes(typeof(FieldAttribute), true);
var fieldAttrs = (FieldAttribute[])Attribute.GetCustomAttributes(prop, typeof(FieldAttribute), true);
string spPropName;
if (fieldAttrs.Length != 0)
{
spPropName = fieldAttrs[0].Name;
if (spPropName == null)
{
spPropName = propName;
}
}
else
{
spPropName = FieldMapper.TranslateToFieldName(propName);
}
if (field == null)
{
field = listItem.Fields.TryGetFieldByStaticName(spPropName);
if (field == null)
{
throw new SharepointCommonException(string.Format("Field '{0}' not exist", propName));
}
}
object fieldValue = value ?? listItem[spPropName];
//------------------------------------
if (field.Type == SPFieldType.User)
{
var f = field as SPFieldLookup;
Assert.NotNull(f);
if (f.AllowMultipleValues == false)
{
var spUser = CommonHelper.GetUser(field.ParentList, spPropName, fieldValue);
if (spUser == null)//todo: why?
{
if (fieldValue == null)
{
return(null);
}
var userValue = new SPFieldUserValue(field.ParentList.ParentWeb, fieldValue.ToString());
return(_proxyGenerator.CreateClassProxy <User>(new UserAccessInterceptor(userValue)));
}
else
{
return(_proxyGenerator.CreateClassProxy <Person>(new UserAccessInterceptor(spUser)));
}
}
else
{
var spUsers = CommonHelper.GetUsers(field.ParentList, spPropName, fieldValue);
var users = new UserIterator(spUsers);
return(users);
}
}
// lookup
if ((field.Type == SPFieldType.Lookup || field.Type == SPFieldType.Invalid) && typeof(Item).IsAssignableFrom(propType))
{
var attr = fieldAttrs[0];
return(GetLookupItemUntype(propType, field, fieldValue, attr));
}
//multi lookup
if ((field.Type == SPFieldType.Lookup || field.Type == SPFieldType.Invalid) &&
(CommonHelper.ImplementsOpenGenericInterface(propType, typeof(IEnumerable <>))))
{
var attr = fieldAttrs[0];
var lookupType = propType.GetGenericArguments()[0];
if (!typeof(Item).IsAssignableFrom(lookupType))
{
throw new SharepointCommonException(string.Format("Type {0} cannot be used as lookup", lookupType));
}
try
{
var meth = typeof(EntityMapper).GetMethod("GetLookupItems", BindingFlags.Static | BindingFlags.NonPublic);
var methGeneric = meth.MakeGenericMethod(lookupType);
var itmId = listItem == null ? null : (int?)listItem.ID;
return(methGeneric.Invoke(null, new[] { field, fieldValue, attr, itmId, reloadLookupItem }));
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
}
if (field.Type == SPFieldType.Guid)
{
var guid = new Guid(fieldValue.ToString());
return(guid);
}
if (field.Type == SPFieldType.Note)
{
if (fieldValue == null)
{
return(null);
}
var text = ((SPFieldMultiLineText)field).GetFieldValueAsText(fieldValue);
return(text);
}
if (propName == "Version")
{
var version = new Version(fieldValue.ToString());
return(version);
}
if (field.Type == SPFieldType.Number)
{
if (propType == typeof(int))
{
int val = Convert.ToInt32(fieldValue);
return(val);
}
if (propType == typeof(double))
{
var val = Convert.ToDouble(fieldValue);
return(val);
}
if (CommonHelper.ImplementsOpenGenericInterface(propType, typeof(Nullable <>)))
{
Type argumentType = propType.GetGenericArguments()[0];
if (argumentType == typeof(int))
{
return(fieldValue == null ? (int?)null : Convert.ToInt32(fieldValue));
}
if (argumentType == typeof(double))
{
return(fieldValue == null ? (double?)null : Convert.ToDouble(fieldValue));
}
}
if (typeof(Item).IsAssignableFrom(propType))
{
if (fieldAttrs.Length == 0 || string.IsNullOrEmpty(fieldAttrs[0].LookupList))
{
throw new SharepointCommonException("To map number field as Item it need been marked with 'FieldAttribute' and set 'LookupList' property");
}
var attr = fieldAttrs[0];
return(GetLookupItemUntype(propType, field, fieldValue, attr));
}
}
if (field.Type == SPFieldType.Boolean)
{
if (propType == typeof(bool))
{
var val = Convert.ToBoolean(fieldValue);
return(val);
}
if (CommonHelper.ImplementsOpenGenericInterface(propType, typeof(Nullable <>)))
{
var argumentType = propType.GetGenericArguments()[0];
if (argumentType == typeof(bool))
{
return(fieldValue == null ? (bool?)null : Convert.ToBoolean(fieldValue));
}
}
if (typeof(Item).IsAssignableFrom(propType))
{
if (fieldAttrs.Length == 0 || string.IsNullOrEmpty(fieldAttrs[0].LookupList))
{
throw new SharepointCommonException(
"To map number field as Item it need been marked with 'FieldAttribute' and set 'LookupList' property");
}
var attr = fieldAttrs[0];
return(GetLookupItemUntype(propType, field, fieldValue, attr));
}
}
if (field.Type == SPFieldType.DateTime)
{
if (propType == typeof(DateTime))
{
var val = CommonHelper.GetDateTimeFieldValue(fieldValue);
return(val);
}
if (CommonHelper.ImplementsOpenGenericInterface(propType, typeof(Nullable <>)))
{
var argumentType = propType.GetGenericArguments()[0];
if (argumentType == typeof(DateTime))
{
var v = fieldValue == null ? (DateTime?)null : CommonHelper.GetDateTimeFieldValue(fieldValue);
return(v);
}
}
}
if (field.Type == SPFieldType.Currency)
{
if (propType == typeof(decimal))
{
decimal val = Convert.ToDecimal(fieldValue);
return(val);
}
if (CommonHelper.ImplementsOpenGenericInterface(propType, typeof(Nullable <>)))
{
Type argumentType = propType.GetGenericArguments()[0];
if (argumentType == typeof(decimal))
{
return(fieldValue == null ? (decimal?)null : Convert.ToDecimal(fieldValue));
}
}
}
if (field.Type == SPFieldType.Text)
{
if ((string)fieldValue == string.Empty)
{
return(null);
}
return(fieldValue);
}
if (field.Type == SPFieldType.Choice)
{
if (propType.IsEnum == false)
{
if (CommonHelper.ImplementsOpenGenericInterface(propType, typeof(Nullable <>)))
{
Type argumentType = propType.GetGenericArguments()[0];
if (argumentType.IsEnum == false)
{
throw new SharepointCommonException(string.Format("Property '{0}' must be declared as enum with fields corresponds to choices", propName));
}
propType = argumentType;
}
if (propType == typeof(string))
{
return(fieldValue);
}
}
return(EnumMapper.ToEntity(propType, fieldValue));
}
if (field.Type == SPFieldType.Calculated)
{
fieldValue = field.GetFieldValueAsText(fieldValue);
}
return(fieldValue);
}
void btn_Save_Click(object sender, EventArgs e)
{
bool UpdateNeeded = false;
foreach (Control control in Fields.Controls)
{
string Id = string.Empty;
string value = string.Empty;
Guid fieldId = Guid.Empty;
if (control.GetType().BaseType == typeof(Html5.WebControls.InputControl))
{
Html5.WebControls.InputControl input = (Html5.WebControls.InputControl)control;
Id = input.ID;
value = input.Text;
}
if (control.GetType().BaseType == typeof(ListControl))
{
ListControl input = (ListControl)control;
Id = input.ID;
if (control.GetType() == typeof(CheckBoxList))
{
foreach (ListItem item in input.Items)
{
if (item.Selected)
{
value += item.Value + ";#";
}
}
value = value.Remove(value.Length - 2);
}
else
{
value = input.SelectedValue;
}
}
if (Hemrika.SharePresence.Common.Validation.GuidTryParse(Id, out fieldId))
{
if (listitem.Fields.Contains(fieldId))
{
SPField field = listitem.Fields[fieldId];
if (field != null)
{
string oldvalue = field.GetFieldValueAsText(listitem[field.InternalName]);
if (oldvalue != value && oldvalue != field.DefaultValue)
{
listitem[fieldId] = value;
UpdateNeeded = true;
}
if (string.IsNullOrEmpty(value) && !string.IsNullOrEmpty(field.DefaultValue) || value == field.DefaultValue)
{
listitem[fieldId] = string.Empty;//field.DefaultValue;
UpdateNeeded = true;
}
}
}
}
}
if (UpdateNeeded)
{
listitem.Update();
}
var eventArgsJavaScript = String.Format("{{Message:'{0}',controlIDs:window.frameElement.dialogArgs}}", "The Properties have been updated.");
((EnhancedLayoutsPage)Page).EndOperation(ModalDialogResult.OK, eventArgsJavaScript);
Context.Response.Flush();
Context.Response.End();
}
private static string GetCellValue(SPListItem li, SPField oField, bool bEditMode, SPWeb oWeb)
{
var currenvyCultureInfo = new CultureInfo(1033);
string val = "";
NumberFormatInfo providerEn = new System.Globalization.NumberFormatInfo();
providerEn.NumberDecimalSeparator = ".";
providerEn.NumberGroupSeparator = ",";
providerEn.NumberGroupSizes = new int[] { 3 };
if (li[oField.Id] != null)
{
val = li[oField.Id].ToString();
switch (oField.Type)
{
case SPFieldType.User:
if (bEditMode)
{
SPFieldUserValueCollection lvc = new SPFieldUserValueCollection(oWeb, val);
val = "";
foreach (SPFieldUserValue lv in lvc)
{
val += ";" + lv.LookupId;
}
val = val.Trim(';');
}
else
{
val = oField.GetFieldValueForEdit(li[oField.Id].ToString());
}
break;
case SPFieldType.Lookup:
if (bEditMode)
{
SPFieldLookupValueCollection lvc = new SPFieldLookupValueCollection(val);
val = "";
foreach (SPFieldLookupValue lv in lvc)
{
val += ";" + lv.LookupId;
}
val = val.Trim(';');
}
else
{
val = oField.GetFieldValueForEdit(li[oField.Id].ToString());
}
break;
case SPFieldType.MultiChoice:
if (bEditMode)
{
SPFieldMultiChoiceValue v = (SPFieldMultiChoiceValue)oField.GetFieldValue(li[oField.Id].ToString());
val = "";
for (int i = 0; i < v.Count; i++)
{
val += ";" + v[i];
}
val = val.Trim(';');
}
else
{
oField.GetFieldValueForEdit(val);
}
break;
case SPFieldType.Calculated:
val = li[oField.Id].ToString();
if (oField.Description == "Indicator" || val.ToLower().EndsWith(".gif") || val.ToLower().EndsWith(".png") || val.ToLower().EndsWith(".jpg"))
{
val = "<img src=\"/_layouts/15/images/" + oField.GetFieldValueAsText(val) + "\">";
}
else
{
val = val.Substring(val.IndexOf(";#") + 2);
}
break;
case SPFieldType.Currency:
try
{
val = ((double)li[oField.Id]).ToString(currenvyCultureInfo.NumberFormat);
}
catch { val = "0"; }
break;
case SPFieldType.Number:
SPFieldNumber fNum = (SPFieldNumber)oField;
if (fNum.ShowAsPercentage)
{
try
{
val = (float.Parse(val) * 100).ToString(providerEn);
}
catch { }
}
else
{
//if (bEditMode)
//{
// val = li[oField.Id].ToString();
//}
//else
// val = oField.GetFieldValueAsText(li[oField.Id].ToString());
try
{
val = ((double)li[oField.Id]).ToString(currenvyCultureInfo.NumberFormat);
}
catch { val = "0"; }
}
break;
case SPFieldType.Boolean:
val = "0";
try
{
if (li[oField.Id].ToString().ToLower() == "yes" || li[oField.Id].ToString().ToLower() == "true")
{
val = "1";
}
}
catch { }
break;
case SPFieldType.DateTime:
try
{
val = ((DateTime)li[oField.Id]).ToString("u");
}
catch { }
break;
default:
if (bEditMode)
{
val = li[oField.Id].ToString();
}
else
{
val = oField.GetFieldValueAsText(li[oField.Id]);
}
break;
}
}
return(val);
}
public string GetFieldValueAsText(object value)
{
return(m_field.GetFieldValueAsText(value));
}
private string getFieldValue(string fieldname, string value)
{
try
{
SPField oField = base.list.Fields.GetFieldByInternalName(fieldname);
switch (oField.Type)
{
case SPFieldType.DateTime:
if (value != "")
{
try
{
DateTime dt = (DateTime)oField.GetFieldValue(value);
return(dt.ToString("yyyy-MM-dd HH:mm:ss"));
}
catch { }
}
return(value);
case SPFieldType.Number:
SPFieldNumber num = (SPFieldNumber)oField;
if (num.ShowAsPercentage)
{
if (value.Contains("%"))
{
return(value.Replace("%", ""));
}
else
{
return((float.Parse(value, providerEn) * 100).ToString(providerEn));
}
}
else
{
return(float.Parse(value, providerEn).ToString(providerEn));
}
case SPFieldType.Calculated:
if (oField.Description == "Indicator")
{
if (value != "" && !value.StartsWith("<img src"))
{
value = "<img src=\"/_layouts/images/" + value.ToLower() + "\">";
}
}
SPFieldCalculated calc = (SPFieldCalculated)oField;
if (calc.ShowAsPercentage)
{
if (value.Contains("%"))
{
return(value.Replace("%", ""));
}
else
{
return((float.Parse(value, providerEn) * 100).ToString(providerEn));
}
}
else
{
return(float.Parse(value, providerEn).ToString(providerEn));
}
case SPFieldType.Boolean:
if (value.ToLower() == "true")
{
return("1");
}
return("0");
case SPFieldType.Note:
return(HttpUtility.HtmlDecode(value));
default:
switch (oField.TypeAsString)
{
case "TotalRollup":
return(oField.GetFieldValueAsText(value));
default:
return(HttpUtility.HtmlDecode(value));
}
}
}
catch { }
return(value);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request["siteid"] != null)
{
SPSite site = null;
SPWeb web = null;
SPList list = null;
GridData gd = new GridData();
bool isRollup = false;
gd.GanttParams64bitString = Request["params"].ToString();
gd.InitRoutine(out isRollup);
SPSecurity.RunWithElevatedPrivileges(delegate()
{
site = new SPSite(new Guid(Request["siteid"].ToString()));
web = site.AllWebs[new Guid(Request["webid"].ToString())];
list = web.Lists[new Guid(Request["listid"].ToString())];
gd.List = list;
//GridUtilities.List = list;
});
try
{
//GridUtilities.View = web.GetViewFromUrl(Request["viewUrl"].ToString());
gd.View = web.GetViewFromUrl(Request["viewUrl"].ToString());
}
catch (Exception ex)
{
try
{
gd.View = web.ParentWeb.GetViewFromUrl(Request["viewUrl"].ToString());
}
catch (Exception ex2)
{
//GridUtilities.AddError("Web: " + web.ServerRelativeUrl + " List: " + list.Title + " View: " + Request["viewUrl"].ToString() + " Message: " + ex2.Message);
}
}
//GridUtilities.InitViewFields();
SPListItem li = gd.List.GetItemById(int.Parse(Request["itemid"].ToString()));
ArrayList imgs = new ArrayList();
if (Request["imgs"].ToString() != string.Empty)
{
imgs.AddRange(Request["imgs"].ToString().Split(",".ToCharArray()));
}
string json = "{ \"FieldValues\": [";
string types = "";
foreach (string sfield in gd.ViewFields)
{
FieldValues fv = new FieldValues();
if (list.Fields.ContainsField(sfield))
{
SPField spField = list.Fields.GetFieldByInternalName(sfield);
types = types + spField.TypeAsString + "|";
fv.fieldKey = gd.GetDisplayName(sfield);
if (!spField.Description.ToLower().Contains("indicator"))
{
string type = spField.TypeAsString;
string val = string.Empty;
switch (type)
{
case "Computed":
fv.dataValue = spField.GetFieldValueAsText(li[spField.Id]);
fv.localizedValue = spField.GetFieldValueAsText(li[spField.Id]);
break;
case "Calculated":
fv.dataValue = spField.GetFieldValueAsText(li[spField.Id]);
fv.localizedValue = spField.GetFieldValueAsText(li[spField.Id]);
break;
case "Text":
fv.dataValue = li[spField.Id];
fv.localizedValue = li[spField.Id];
break;
case "Number":
if (li[spField.Id] != null && li[spField.Id].ToString() != "")
{
if (spField.InternalName.ToLower() != "percentcomplete")
{
val = String.Format("{0:#,0.00}", li[spField.Id]);
}
else
{
decimal pct = decimal.Parse(li[spField.Id].ToString());
pct = pct * 100;
val = String.Format("{0:#,0.00}", pct.ToString());
val = val + " %";
}
}
fv.dataValue = val;
fv.localizedValue = val;
break;
case "Currency":
if (li[spField.Id] != null)
{
val = String.Format("{0:C}", li[spField.Id]);
}
fv.dataValue = val;
fv.localizedValue = val;
break;
case "Boolean":
fv.dataValue = spField.GetFieldValueAsText(li[spField.Id]);
fv.localizedValue = spField.GetFieldValueAsText(li[spField.Id]);
break;
case "Note":
fv.dataValue = li[spField.Id];
fv.localizedValue = li[spField.Id];
break;
case "DateTime":
SPFieldDateTime spfdt = (SPFieldDateTime)spField;
if (spfdt.DisplayFormat == SPDateTimeFieldFormatType.DateTime)
{
if (li[spField.Id] != null)
{
val = DateTime.Parse(li[spField.Id].ToString()).ToString();
}
fv.dataValue = val;
fv.localizedValue = val;
}
else
{
if (li[spField.Id] != null)
{
val = DateTime.Parse(li[spField.Id].ToString()).ToShortDateString();
}
fv.dataValue = val;
fv.localizedValue = val;
}
break;
default:
fv.dataValue = spField.GetFieldValueAsText(li[spField.Id]);
fv.localizedValue = spField.GetFieldValueAsText(li[spField.Id]);
break;
}
}
else
{
string val = spField.GetFieldValueAsText(li[spField.Id]).ToLower();
fv.dataValue = imgs.IndexOf(spField.GetFieldValueAsText(li[spField.Id]).ToLower());
fv.localizedValue = "";
}
Serializer s = new Serializer();
json = json + fv.ToJson(s) + ",";
}
}
json = json.Remove(json.LastIndexOf(","));
json = json + "]}";
Response.Output.WriteLine(json);
}
else
{
Response.Output.WriteLine("Failed");
}
//GridUtilities.WriteLog();
//GridUtilities.IDisposable();
}
public Columns AsColumn(SPListItem spListItem, SPField field)
{
string columnType = this.GetDataBaseType(field.Type);
object fValue = null;
try
{
fValue = spListItem[field.InternalName];
}
catch {}
string columnValue = string.Empty;
if (field.InternalName == this.KeyFieldName)
{
columnValue = fValue == null ? string.Empty : fValue.ToString();
}
else if (field is SPFieldLookup)
{
columnValue = fValue == null ? string.Empty : fValue.ToString();
}
else if (field is SPFieldDateTime)
{
try
{
if (fValue != null)
{
const string format = "yyyy-MM-dd HH:mm:ss:fff";
DateTime dateTime = (DateTime)fValue;
columnValue = dateTime.ToString(format);
}
}
catch (Exception ex)
{
Logger.WriteError(ex.Message, ex);
columnValue = string.Empty;
}
}
else
{
if (fValue != null)
{
columnValue = field.GetFieldValueAsText(fValue) ?? fValue.ToString();
}
}
if (columnValue.ToUpperInvariant() == "NO" || columnValue.ToUpperInvariant() == "НЕТ")
{
columnValue = "0";
}
if (columnValue.ToUpperInvariant() == "YES" || columnValue.ToUpperInvariant() == "ДА")
{
columnValue = "1";
}
if (columnType == FloatType && field.InternalName != this.KeyFieldName)
{
columnValue = columnValue.Trim().Replace(",", ".").Replace(((char)0xA0).ToString(), "");
}
Columns item = new Columns
{
ColumnName = field.Id == SPBuiltInFieldId.ID ? Constants.ColumnSpPrefix + field.InternalName : field.InternalName,
ColumnType = columnType,
ColumnValue = columnValue
};
return(item);
}
private void SetValueToEntity(SPListItem item, T entity, string columnName, string propertyName)
{
object value;
try
{
SPField field = item.Fields.GetField(columnName);
value = item[field.Id];
}
catch (Exception)
{
value = null;
}
if (!item.Fields.ContainsField(columnName))
{
return;
}
SPField currentField = item.Fields.GetField(columnName);
if (currentField is SPFieldCalculated)
{
try
{
value = currentField.GetFieldValueAsText(value);
Type propertyType = typeof(T).GetProperty(propertyName).PropertyType;
value = TryConvertSimpleValueType(value, propertyType);
}
catch (Exception ex)
{
throw new ArgumentNullException("Error on getting calculated value", ex);
}
}
else if (value != null)
{
Type propertyType = typeof(T).GetProperty(propertyName).PropertyType;
value = TryConvertSimpleValueType(value, propertyType);
if (propertyType == typeof(LookupItem))
{
value = item.ToLookupItemModel(columnName);
}
else if (propertyType == typeof(List <LookupItem>))
{
value = item.ToLookupItemsModel(columnName);
}
else if (propertyType == typeof(List <string>))
{
value = item.ToValuesFromMultiChoice(columnName);
}
else if (propertyType == typeof(List <User>))
{
value = item.ToUsersModel(columnName);
}
else if (propertyType == typeof(User))
{
value = item.ToUserModel(columnName);
}
else if (propertyType == typeof(SPGroup))
{
value = item.ToGroup(columnName);
}
}
try
{
typeof(T).InvokeMember(
propertyName,
BindingFlags.SetProperty,
null,
entity,
new[] { value });
}
catch (Exception ex)
{
string errorMessage = string.Format("Error when setting property '{0}' value '{1}'",
propertyName, value);
throw new ArgumentNullException(errorMessage, ex);
}
}
protected override void Render(HtmlTextWriter __w)
{
int num2 = 40;
Guid guid;
SPQuery query;
bool flag = "1".Equals(base.Request["b"]);
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
int num = 40;
int num3 = 0;
int num4 = -1;
int num5 = 0;
string str = base.Request["fs"];
string str6 = (base.Request["q"] + string.Empty).Trim();
string str7 = (flag = flag ? true : ((str6.Length != 1) ? false : ProductPage.Config <bool>(ProductPage.GetContext(), "Auto1Begins"))) ? "BeginsWith" : "Contains";
SPList list = null;
SPView defaultView = null;
SPListItemCollection collection = null;
List <string> list2 = new List <string>();
List <string> list3 = new List <string>();
List <SPField> list4 = new List <SPField>();
if (!int.TryParse(ProductPage.Config(ProductPage.GetContext(), "AutoLimit"), out num2) || (num2 <= 1))
{
num2 = num;
}
//if (!int.TryParse(base.Request["limit"], out num2) || (num2 <= 1))
//{
// num2 = num;
//}
try
{
list = SPContext.Current.Web.Lists[ProductPage.GetGuid(base.Request["l"])];
}
catch
{
}
if (list == null)
{
__w.Write(ProductPage.GetProductResource("AutoNoList", new object[] { ProductPage.GetGuid(base.Request["l"]) }));
goto Label_0876;
}
SPField field = ProductPage.GetField(list, base.Request["f"]);
if (field == null)
{
__w.Write(ProductPage.GetProductResource("AutoNoField", new object[] { base.Request["f"] }));
goto Label_0876;
}
if (string.IsNullOrEmpty(str6))
{
goto Label_0876;
}
foreach (string str8 in (base.Request["sf"] + string.Empty).Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries))
{
SPField field2 = ProductPage.GetField(list, str8);
if (field2 != null)
{
list4.Add(field2);
}
}
SPFieldCalculated calculated = field as SPFieldCalculated;
SPFieldUrl url = field as SPFieldUrl;
SPFieldLookup lookup = field as SPFieldLookup;
if (!string.IsNullOrEmpty(base.Request["v"]) && !Guid.Empty.Equals(guid = ProductPage.GetGuid(base.Request["v"])))
{
try
{
defaultView = list.Views[guid];
}
catch
{
}
}
if (defaultView == null)
{
defaultView = list.DefaultView;
}
Label_02A7:
for (int queryNum = 0; queryNum < 2; queryNum++)
{
if (list2.Count >= num2)
{
break;
}
query = new SPQuery(defaultView);
query.Folder = list.RootFolder;
query.IncludeAllUserPermissions = query.IncludeMandatoryColumns = query.IncludePermissions = query.IndividualProperties = query.AutoHyperlink = query.ExpandRecurrence = query.ExpandUserField = query.IncludeAttachmentVersion = query.IncludeAttachmentUrls = query.ItemIdQuery = false;
query.ViewAttributes = "FailIfEmpty=\"FALSE\" RequiresClientIntegration=\"FALSE\" Threaded=\"FALSE\" Scope=\"Recursive\"";
query.ViewFields = "<FieldRef Name=\"" + field.InternalName + "\"/>";
foreach (SPField field3 in list4)
{
query.ViewFields = query.ViewFields + "<FieldRef Name=\"" + field3.InternalName + "\"/>";
}
string str5 = (calculated != null) ? calculated.OutputType.ToString() : field.TypeAsString;
flag2 = Array.IndexOf <string>(nonTextFieldTypes, field.TypeAsString) >= 0;
Array.IndexOf <string>(unsupportedFieldTypes, field.TypeAsString);
ArrayList alist = new ArrayList();
if (queryNum == 0)
{
alist.Add(str6);
query.Query = (flag4 ? string.Empty : ("<Where><" + str7 + "><FieldRef Name=\"" + field.InternalName + "\" /><Value Type=\"" + (flag3 ? "Text" : str5) + "\">" + str6 + "</Value></" + str7 + "></Where>")) + "<OrderBy><FieldRef Name=\"" + field.InternalName + "\"/></OrderBy>";
}
else
{
try
{
Segment segment = new Segment();
Segment.Init(Server.MapPath("/_layouts/PanGuSegment/PanGu.xml"));
ICollection <WordInfo> words = segment.DoSegment(str6);
string queryCondition = "";
Dictionary <string, string> listCamls = new Dictionary <string, string>();
string testDrawCamlTree = "";
int i = 1;
foreach (WordInfo wordInfo in words)
{
if (wordInfo != null && wordInfo.Word.Replace(" ", "") != "" && wordInfo.Word.Length == 1)
{
alist.Add(wordInfo.Word);
testDrawCamlTree += "0-And:" + i + ";";
listCamls.Add(i.ToString(), "<" + str7 + "><FieldRef Name=\"" + field.InternalName + "\" /><Value Type=\"" + (flag3 ? "Text" : str5) + "\">" + wordInfo.Word + "</Value></" + str7 + ">");
i++;
}
}
if (listCamls.Count > 0)
{
query.Query = (flag4 ? string.Empty : "<Where>" + BSTUtils.DrawCamlTree(testDrawCamlTree.TrimEnd(';'), listCamls) + "</Where>") + "<OrderBy><FieldRef Name=\"" + field.InternalName + "\"/></OrderBy>";
}
else
{
break;
}
}
catch (Exception ex)
{
break;
}
}
query.RowLimit = (uint)100000;
collection = list.GetItems(query);
if (collection != null)
{
num4 = 0;
foreach (SPListItem item in ProductPage.TryEach <SPListItem>(collection))
{
string lookupValue;
string str3 = string.Empty;
string str4 = string.Empty;
foreach (SPField field4 in list4)
{
if ((field4 != null) && !Guid.Empty.Equals(field4.Id))
{
try
{
str4 = item[field4.Id] + string.Empty;
}
catch
{
str4 = string.Empty;
}
}
if (!string.IsNullOrEmpty(str4))
{
string str11 = str3;
str3 = str11 + "<div class=\"rox-acsecfield\"><i>" + base.Server.HtmlEncode(field4.Title) + ":</i> " + str4.Replace("\r\n", " ").Replace("\r", " ").Replace("\n", " ") + "</div>";
}
}
num4++;
string[] strArray = null;
object obj2 = ProductPage.GetFieldVal(item, field, true);
if (!string.IsNullOrEmpty(lookupValue = (obj2 == null) ? string.Empty : field.GetFieldValueAsText(obj2)))
{
if (!IsContains(lookupValue.Trim(), alist))
{
lookupValue = string.Empty;
}
else if (lookup != null)
{
SPFieldUserValueCollection values2 = obj2 as SPFieldUserValueCollection;
if (values2 != null)
{
lookupValue = string.Empty;
strArray = values2.ConvertAll <string>(uv => uv.LookupValue).ToArray();
}
else
{
SPFieldLookupValueCollection values = obj2 as SPFieldLookupValueCollection;
if (values != null)
{
lookupValue = string.Empty;
strArray = values.ConvertAll <string>(lv => lv.LookupValue).ToArray();
}
else
{
SPFieldLookupValue value2 = obj2 as SPFieldLookupValue;
if (value2 != null)
{
lookupValue = value2.LookupValue;
}
}
}
}
else
{
SPFieldUrlValue value3;
if ((url != null) && ((value3 = obj2 as SPFieldUrlValue) != null))
{
lookupValue = value3.Url;
}
else if (field.Type == SPFieldType.MultiChoice)
{
strArray = (obj2 + string.Empty).Split(new string[] { ";#" }, StringSplitOptions.RemoveEmptyEntries);
}
else if (!string.IsNullOrEmpty(str))
{
strArray = (obj2 + string.Empty).Split(new string[] { str }, StringSplitOptions.RemoveEmptyEntries);
}
}
}
if (!IsContains(lookupValue.Trim(), alist))
{
lookupValue = string.Empty;
}
if (strArray != null)
{
for (int i = 0; i < strArray.Length; i++)
{
if (!IsContains(strArray[i].Trim(), alist))
{
strArray[i] = string.Empty;
}
}
}
else if (!string.IsNullOrEmpty(lookupValue))
{
strArray = new string[] { lookupValue };
}
else
{
strArray = new string[0];
}
if (strArray.Length > 0)
{
num3++;
foreach (string str9 in strArray)
{
if ((!string.IsNullOrEmpty(str9) && (IsContains(str9.Trim(), alist))) && !list2.Contains(str9.Trim()))
{
list3.Add(str3);
list2.Add(str9.Trim());
}
}
}
if (list2.Count >= num2)
{
break;
}
}
}
}
if (num4 < (flag2 ? 1 : 0))
{
if (flag2 && !flag3)
{
flag3 = true;
goto Label_02A7;
}
if (!flag4)
{
flag4 = true;
goto Label_02A7;
}
}
Label_0876:
//list2.Sort();
foreach (string str10 in list2)
{
__w.Write(str10.Replace("\r\n", " ").Replace("\r", " ").Replace("\n", " ") + list3[num5++] + "\r\n");
}
}
public override void ItemUpdating(SPItemEventProperties properties)
{
bool allHidden = true;
try
{
var list = SaveDataJobExecuteCache.GetList(properties);
foreach (System.Collections.DictionaryEntry sField in properties.AfterProperties)
{
if (!list.Fields.GetFieldByInternalName(sField.Key.ToString()).Hidden)
{
allHidden = false;
break;
}
}
}
catch { allHidden = false; }
if (properties.AfterProperties["Publisher_x0020_Approval_x0020_S"] != null)
{
return;
}
if (!allHidden && properties.AfterProperties["IsPublished"] == null)
{
properties.AfterProperties["IsPublished"] = "0";
try
{
SPFieldLookupValue lv = new SPFieldLookupValue(SaveDataJobExecuteCache.GetListItem(properties)["Project"].ToString());
SPField f = SaveDataJobExecuteCache.GetList(properties).Fields.GetFieldByInternalName("Project");
XmlDocument doc = new XmlDocument();
doc.LoadXml(f.SchemaXml);
string listid = doc.FirstChild.Attributes["List"].Value;
var web = properties.Web;
SPList list = web.Lists[new Guid(listid)];
SPListItem li = list.GetItemById(lv.LookupId);
if (list.Fields.ContainsFieldWithInternalName("PendingUpdates"))
{
SPField fPend = list.Fields.GetFieldByInternalName("PendingUpdates");
string pending = "";
try
{
pending = fPend.GetFieldValueAsText(li[fPend.Id].ToString());
}catch {}
if (pending != "Yes")
{
li[fPend.Id] = 1;
li.SystemUpdate();
ArrayList arr = new ArrayList();
SPFieldUserValue uv = new SPFieldUserValue(web, li["Author"].ToString());
arr.Add(uv.LookupId);
try
{
SPFieldUserValueCollection uvc = new SPFieldUserValueCollection(web, li["Planners"].ToString());
foreach (SPFieldUserValue u in uvc)
{
if (!arr.Contains(u.LookupId))
{
arr.Add(u.LookupId);
}
}
}catch {}
try
{
SPFieldUserValueCollection uvc = new SPFieldUserValueCollection(web, li["Project Manager"].ToString());
foreach (SPFieldUserValue u in uvc)
{
if (!arr.Contains(u.LookupId))
{
arr.Add(u.LookupId);
}
}
}
catch { }
Hashtable hshProps = new Hashtable();
hshProps.Add("ProjectName", li.Title);
hshProps.Add("ListId", list.ID.ToString());
hshProps.Add("ItemId", li.ID.ToString());
//string body = Properties.Resources.txtPendingUpdateEmail;
//body = body.Replace("{ProjectName}", li.Title);
//body = body.Replace("{ListId}", list.ID.ToString());
//body = body.Replace("{ItemId}", li.ID.ToString());
foreach (int i in arr)
{
try
{
//SPSecurity.RunWithElevatedPrivileges(delegate()
//{
SPUser u = web.SiteUsers.GetByID(1073741823);
API.APIEmail.QueueItemMessage(5, true, hshProps, new string[] { i.ToString() }, null, false, true, li, u, false);
//});
//API.APIEmail.sendEmailHideReply(5, properties.SiteId, properties.Web.ID, properties.Web.CurrentUser, properties.Web.SiteUsers.GetByID(i), hshProps);
}
catch { }
}
}
}
}
catch { }
}
}
private void ProcessSiteQueryData(string sListName)
{
const int xAxisColumnIndex = 3;
const int zAxisFieldIndex = 4;
try
{
var xAxisField = oTopList.Fields.GetFieldByInternalName(PropChartXaxisField);
SPField zAxisField = null;
if (!PropChartZaxisField.Contains("None Selected"))
{
zAxisField = oTopList.Fields.GetFieldByInternalName(PropChartZaxisField);
}
AddZAxisRowToChartDataTable(xAxisColumnIndex, xAxisField);
foreach (DataRow dr in dtSPSiteDataQueryData.Rows)
{
var xAxisFieldValue = GetXaxisFieldValue(sListName, xAxisField, xAxisColumnIndex, dr);
var zAxisFieldValue = GetZaxisFieldValue(sListName, zAxisField, zAxisFieldIndex, dr);
var sYaxisFldVal = "";
AddXAxisColumnToChartDataTableIfDoesntExist(xAxisFieldValue);
switch (PropChartAggregationType.ToUpper())
{
case "COUNT":
if (PropChartZaxisField.Trim().Length != 0 && !PropChartZaxisField.Contains("None Selected"))
{
if (zAxisFieldValue.Trim() == "")
{
zAxisFieldValue = "No Value";
}
if (SeriesExistsInChartDataTable(zAxisFieldValue))
{
UpdateCellValue(zAxisFieldValue, xAxisFieldValue, zAxisFieldValue, PropChartAggregationType);
_numberOfRowsInChartDataTable++;
}
else
{
AddNewRowToChartDataTable(zAxisFieldValue);
_numberOfRowsInChartDataTable++;
UpdateCellValue(zAxisFieldValue, xAxisFieldValue, zAxisFieldValue, PropChartAggregationType);
}
}
else
{
if (xAxisField.InternalName.ToUpper() == "LIST")
{
UpdateCellValue(xAxisField.Title, xAxisFieldValue, "1", "COUNT");
}
else
{
UpdateCellValue(dtSPSiteDataQueryData.Columns[xAxisColumnIndex].ColumnName, xAxisFieldValue, "1", "COUNT");
}
_numberOfRowsInChartDataTable++;
}
break;
case "SUM":
case "AVG":
if (PropChartAggregationType.ToUpper() != "SUM" && (PropChartZaxisField.Trim() != "" && !PropChartZaxisField.Contains("None Selected")))
{
if (zAxisFieldValue.Trim().Length == 0)
{
zAxisFieldValue = "No Value";
}
if (GetYFields().Length > 0)
{
if (SeriesExistsInChartDataTable(zAxisFieldValue))
{
UpdateCellValue(zAxisFieldValue, xAxisFieldValue, sYaxisFldVal,
PropChartAggregationType);
_numberOfRowsInChartDataTable++;
}
else
{
AddNewRowToChartDataTable(zAxisFieldValue);
_numberOfRowsInChartDataTable++;
UpdateCellValue(zAxisFieldValue, xAxisFieldValue, sYaxisFldVal,
PropChartAggregationType);
}
}
else
{
if (dtSPSiteDataQueryData.Columns.Count > 5)
{
if (
SeriesExistsInChartDataTable(zAxisField.GetFieldValueAsText(dtSPSiteDataQueryData.Columns[5].ColumnName)))
{
UpdateCellValue(dtSPSiteDataQueryData.Columns[5].ColumnName, xAxisFieldValue,
zAxisFieldValue, PropChartAggregationType);
_numberOfRowsInChartDataTable++;
}
else
{
AddNewRowToChartDataTable(dtSPSiteDataQueryData.Columns[5].ColumnName);
_numberOfRowsInChartDataTable++;
UpdateCellValue(dtSPSiteDataQueryData.Columns[5].ColumnName, xAxisFieldValue,
zAxisFieldValue, PropChartAggregationType);
}
}
else
{
if (dtSPSiteDataQueryData.Columns[zAxisFieldIndex].ColumnName.ToUpper() == "LIST")
{
if (zAxisField != null)
{
if (SeriesExistsInChartDataTable(zAxisField.Title))
{
UpdateCellValue(zAxisField.Title, xAxisFieldValue, zAxisFieldValue,
PropChartAggregationType);
_numberOfRowsInChartDataTable++;
}
else
{
AddNewRowToChartDataTable(zAxisField.Title);
_numberOfRowsInChartDataTable++;
UpdateCellValue(zAxisField.Title, xAxisFieldValue, zAxisFieldValue,
PropChartAggregationType);
}
}
else
{
if (SeriesExistsInChartDataTable("Work Type"))
{
UpdateCellValue("Work Type", xAxisFieldValue, zAxisFieldValue,
PropChartAggregationType);
_numberOfRowsInChartDataTable++;
}
else
{
AddNewRowToChartDataTable("Work Type");
_numberOfRowsInChartDataTable++;
UpdateCellValue("Work Type", xAxisFieldValue, zAxisFieldValue,
PropChartAggregationType);
}
}
}
}
}
}
if (GetYFields().Length > 0)
{
string sSeriesName;
int iStartCol;
if (!PropChartZaxisField.Contains("None Selected") && !IsBubbleChart())
{
iStartCol = 5;
}
else
{
iStartCol = 4;
}
SPField fldYaxis;
if (!IsBubbleChart())
{
for (int iSeries = iStartCol; iSeries < dtSPSiteDataQueryData.Columns.Count; iSeries++)
{
SetGraphData(iSeries, dr, zAxisFieldValue, xAxisFieldValue);
}
}
else
{
SetGraphData(iStartCol, dr, zAxisFieldValue, xAxisFieldValue);
}
}
break;
default:
break;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public static object GetListItemVersionObject(ScriptEngine engine, SPListItemVersion version, SPField field)
{
switch (field.Type)
{
case SPFieldType.Integer:
{
int value;
if (version.TryGetSPFieldValue(field.InternalName, out value))
{
return(value);
}
}
break;
case SPFieldType.Boolean:
{
bool value;
if (version.TryGetSPFieldValue(field.InternalName, out value))
{
return(value);
}
}
break;
case SPFieldType.Number:
{
double value;
if (version.TryGetSPFieldValue(field.InternalName, out value))
{
return(value);
}
}
break;
case SPFieldType.DateTime:
{
DateTime value;
if (version.TryGetSPFieldValue(field.InternalName, out value))
{
return(JurassicHelper.ToDateInstance(engine, new DateTime(value.Ticks, DateTimeKind.Local)));
}
}
break;
case SPFieldType.URL:
{
string urlFieldValue;
if (version.TryGetSPFieldValue(field.InternalName, out urlFieldValue))
{
var urlValue = new SPFieldUrlValue(urlFieldValue);
var item = engine.Object.Construct();
item.SetPropertyValue("description", urlValue.Description, false);
item.SetPropertyValue("url", urlValue.Url, false);
return(item);
}
}
break;
case SPFieldType.User:
{
string userToken;
if (version.TryGetSPFieldValue(field.InternalName, out userToken))
{
var fieldUserValue = new SPFieldUserValue(version.ListItem.Web, userToken);
var userInstance = new SPUserInstance(engine, fieldUserValue.User);
return(userInstance);
}
}
break;
case SPFieldType.Lookup:
{
var fieldType = field as SPFieldLookup;
if (fieldType == null)
{
return(null);
}
if (fieldType.AllowMultipleValues)
{
object fv;
if (!version.TryGetSPFieldValue(field.InternalName, out fv))
{
return(null);
}
var fieldValue = fv as SPFieldLookupValueCollection;
var array = engine.Array.Construct();
if (fieldValue != null)
{
foreach (var lookupValue in fieldValue)
{
var item = engine.Object.Construct();
item.SetPropertyValue("lookupId", lookupValue.LookupId, false);
item.SetPropertyValue("lookupValue", lookupValue.LookupValue, false);
ArrayInstance.Push(array, item);
}
}
return(array);
}
else
{
object fieldValue;
if (!version.TryGetSPFieldValue(field.InternalName, out fieldValue))
{
return(null);
}
var fieldUrlValue = fieldValue as SPFieldUrlValue;
if (fieldUrlValue != null)
{
var urlValue = fieldUrlValue;
var item = engine.Object.Construct();
item.SetPropertyValue("description", urlValue.Description, false);
item.SetPropertyValue("url", urlValue.Url, false);
return(item);
}
if (fieldValue is DateTime)
{
var value = (DateTime)fieldValue;
return(JurassicHelper.ToDateInstance(engine,
new DateTime(value.Ticks, DateTimeKind.Local)));
}
var userValue = fieldValue as SPFieldUserValue;
if (userValue != null)
{
var fieldUserValue = userValue;
var userInstance = new SPUserInstance(engine, fieldUserValue.User);
return(userInstance);
}
if (fieldValue is Guid)
{
var guidValue = (Guid)fieldValue;
var guidInstance = new GuidInstance(engine.Object.InstancePrototype, guidValue);
return(guidInstance);
}
var s = fieldValue as string;
if (s == null)
{
return(fieldValue);
}
//Attempt to create a new SPFieldLookupValue from the string
if (!DigitRegex.IsMatch(s, 0))
{
return(fieldValue);
}
try
{
var lookupValue = new SPFieldLookupValue(s);
var item = engine.Object.Construct();
item.SetPropertyValue("lookupId", lookupValue.LookupId, false);
item.SetPropertyValue("lookupValue", lookupValue.LookupValue, false);
return(item);
}
catch (ArgumentException)
{
return(fieldValue);
}
}
}
default:
{
object value;
if (version.TryGetSPFieldValue(field.InternalName, out value))
{
var stringValue = field.GetFieldValueAsText(value);
return(stringValue);
}
}
break;
}
return(null);
}
private string getFieldVal(string field, SPItemEventProperties properties, SPList list)
{
try
{
SPField f = list.Fields.GetFieldByInternalName(field);
string val = properties.AfterProperties[field].ToString();
if (f.Type == SPFieldType.DateTime)
{
val = val.Replace("T", " ").Replace("Z", "");
}
if (val == "")
{
return("");
}
switch (f.Type)
{
case SPFieldType.DateTime:
try
{
val = f.GetFieldValue(val).ToString();
DateTime dt = DateTime.Parse(val);
SPFieldDateTime dtF = (SPFieldDateTime)f;
if (dtF.DisplayFormat == SPDateTimeFieldFormatType.DateOnly)
{
return(dt.ToShortDateString());
}
else
{
return(dt.ToString());
}
}catch {}
return("");
case SPFieldType.Lookup:
if (val != "")
{
if (val.Contains(";#"))
{
return(f.GetFieldValueAsText(val));
}
else
{
SPList lookupList = properties.Web.Lists[new Guid(((SPFieldLookup)f).LookupList)];
SPListItem lookupItem = lookupList.GetItemById(int.Parse(val));
return(lookupItem[((SPFieldLookup)f).LookupField].ToString());
}
}
return("");
default:
return(f.GetFieldValue(val).ToString());
}
;
}
catch { }
return("");
}
public static void processMeta(SPWeb iWeb, SPList iList, SPListItem li, Guid newTS, string project, SqlConnection cn, SPList pList)
{
string[] fields = EPMLiveCore.CoreFunctions.getConfigSetting(iWeb.Site.RootWeb, "EPMLiveTSFields-" + System.IO.Path.GetDirectoryName(iList.DefaultView == null ? iList.DefaultViewUrl : iList.DefaultView.Url)).Split(',');
SqlCommand cmd = new SqlCommand("DELETE FROM TSMETA WHERE TS_ITEM_UID = @TS_ITEM_UID", cn);
cmd.Parameters.AddWithValue("@TS_ITEM_UID", newTS);
cmd.ExecuteNonQuery();
cmd = new SqlCommand("UPDATE tsitem set title = @title,PROJECT_LIST_UID=@projectlistuid where ts_item_uid=@itemuid", cn);
cmd.Parameters.AddWithValue("@itemuid", newTS);
cmd.Parameters.AddWithValue("@title", li.Title);
if (pList != null)
{
cmd.Parameters.AddWithValue("@projectlistuid", pList.ID);
}
else
{
cmd.Parameters.AddWithValue("@projectlistuid", DBNull.Value);
}
cmd.ExecuteNonQuery();
foreach (string field in fields)
{
SPField f = null;
string val = "";
try
{
f = iList.Fields.GetFieldByInternalName(field);
switch (f.Type)
{
case SPFieldType.DateTime:
val = f.GetFieldValueAsText(((DateTime)li[f.Id]).ToUniversalTime());
break;
default:
val = f.GetFieldValueAsText(li[f.Id]);
break;
}
;
}
catch { }
if (f != null)
{
cmd = new SqlCommand("INSERT INTO TSMETA (TS_ITEM_UID,ColumnName,DisplayName,ColumnValue,ListName) VALUES (@TS_ITEM_UID,@ColumnName,@DisplayName,@ColumnValue,@ListName)", cn);
cmd.Parameters.AddWithValue("@TS_ITEM_UID", newTS);
cmd.Parameters.AddWithValue("@ColumnName", field);
cmd.Parameters.AddWithValue("@DisplayName", f.Title);
cmd.Parameters.AddWithValue("@ColumnValue", val);
cmd.Parameters.AddWithValue("@ListName", li.ParentList.Title);
cmd.ExecuteNonQuery();
}
}
if (pList != null && project != "")
{
fields = EPMLiveCore.CoreFunctions.getConfigSetting(iWeb.Site.RootWeb, "EPMLiveTSFields-Lists\\" + pList.Title).Split(',');
SPQuery query = new SPQuery();
query.Query = "<Where><Eq><FieldRef Name='Title'/><Value Type='Text'>" + project + "</Value></Eq></Where>";
SPListItemCollection lic = pList.GetItems(query);
if (lic.Count > 0)
{
foreach (string field in fields)
{
SPField f = null;
string val = "";
try
{
f = pList.Fields.GetFieldByInternalName(field);
val = f.GetFieldValueAsText(lic[0][f.Id]);
}
catch { }
if (f != null)
{
try
{
cmd = new SqlCommand("INSERT INTO TSMETA (TS_ITEM_UID,ColumnName,DisplayName,ColumnValue,ListName) VALUES (@TS_ITEM_UID,@ColumnName,@DisplayName,@ColumnValue,@ListName)", cn);
cmd.Parameters.AddWithValue("@TS_ITEM_UID", newTS);
cmd.Parameters.AddWithValue("@ColumnName", field);
cmd.Parameters.AddWithValue("@DisplayName", f.Title);
cmd.Parameters.AddWithValue("@ColumnValue", val);
cmd.Parameters.AddWithValue("@ListName", pList.Title);
cmd.ExecuteNonQuery();
}
catch { }
}
}
}
}
}
private void processSection(SPWeb web, string sUser, string sSectionName, string sLists, string sCols, string sQuery)
{
string[] arColNames = sCols.Replace("\r\n", "\r").Split(chrCRSeparator, StringSplitOptions.RemoveEmptyEntries); // separate the multiple items in each column by newline/carriage return
SPQuery spquery = new SPQuery();
spquery.Query = sQuery;
string[] arListNames = sLists.Replace("\r\n", "\r").Split(chrCRSeparator, StringSplitOptions.RemoveEmptyEntries);
foreach (string sListName in arListNames)
{
try
{
if (sListName.Contains("|"))
{
string[] arListName = sListName.Split('|');
list = web.Lists[arListName[0].Trim()] as SPList;
}
else
{
list = web.Lists[sListName] as SPList;
}
if (list != null)
{
SPListItemCollection colListItems = list.GetItems(spquery);
try
{
int cntItems = colListItems.Count;
if (cntItems > 0)
{
// process column names to remove pipe char and get the internal name
string sParsedColName;
int i = 0;
foreach (string sColName in arColNames)
{
if (sColName.Trim() != "")
{
sParsedColName = getSplitVal(sColName, 0, "|");
arColNames[i] = sParsedColName;
i++;
}
}
string val = "";
foreach (SPListItem li in colListItems)
{
int cntFields = arColNames.Length;
string[] sNewRow = new string[cntFields];
int cnt = 0;
foreach (string sColName in arColNames)
{
if (sColName.Trim() != "")
{
try
{
SPField field = li.Fields.GetFieldByInternalName(sColName);
if (li[field.Id] != null)
{
val = li[field.Id].ToString();
if (!isDate(val))
{
val = field.GetFieldValueAsText(val);
}
else
{
try
{
DateTime dt = DateTime.Parse(val);
//int localeID = (int)web.RegionalSettings.LocaleId;
System.Globalization.CultureInfo cInfo = new System.Globalization.CultureInfo(web.Locale.LCID);
IFormatProvider culture = new System.Globalization.CultureInfo(cInfo.Name, true);
if (getFieldSchemaAttribValue(field.SchemaXml, "Format").ToUpper() == "DATEONLY")
{
val = dt.ToUniversalTime().GetDateTimeFormats(culture)[0]; //dt.ToShortDateString();
}
else
{
val = dt.ToUniversalTime().GetDateTimeFormats(culture)[72]; //dt.ToShortDateString() + " " + dt.ToShortTimeString();
}
}
catch { }
}
if (field.SchemaXml.IndexOf("Percentage") > 0 && getFieldSchemaAttribValue(field.SchemaXml, "Percentage").ToUpper() == "TRUE") // if check box 'Show as percentage is checked
{
val = val.Replace(" ", ""); // take out space between number and % symbol
}
if (field.InternalName == "Title")
{
val = "<a href=\"" + web.Url + "/" + list.Forms[PAGETYPE.PAGE_DISPLAYFORM].Url + "?ID=" + li.ID + "\" style=\"color:#0090ca;text-decoration:none\">" + val + "</a>";
}
sNewRow[cnt] = val;
}
}
catch (Exception exc)
{
if ((bLogDetailedErrors) && (ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.FieldLevelErrors)
{
logException("NotificationListsJob.processSection", exc.Message, "Error retrieving field value. Field: " + sColName + " Web: " + web.Name + " Section Name: " + sSectionName + " List Name: " + sListName);
}
}
cnt++;
}
}
dsSectionTables.Tables[sSectionName].Rows.Add(sNewRow);
}
}
}
catch (Exception exc)
{
if ((bLogDetailedErrors) && ((ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.ListLevelErrors || (ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.FieldLevelErrors))
{
logException("NotificationListsJob.processSection", exc.Message, "Error when querying list. Web: " + web.Name + " Query: " + sQuery + " - Section Name: " + sSectionName + " List Name: " + sListName);
}
}
}
}
catch (Exception exc)
{
if ((bLogDetailedErrors) && ((ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.SectionLevelErrors || (ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.ListLevelErrors || (ErrorLogDetailLevelEnum)iErrorLogDetailLevel == ErrorLogDetailLevelEnum.FieldLevelErrors))
{
logException("NotificationListsJob.processSection", exc.Message, "List does not exist Web: " + web.Name + " Section Name: " + sSectionName + " List Name: " + sListName);
}
}
}
}
static internal void processResources(SqlConnection cn, string tsuid, SPWeb web, string username)
{
string rate = GetStandardRates(cn, tsuid, web, username);
SqlCommand cmd = new SqlCommand("DELETE FROM TSRESMETA where TS_UID = @TS_UID", cn);
cmd.Parameters.AddWithValue("@TS_UID", tsuid);
cmd.ExecuteNonQuery();
string resUrl = EPMLiveCore.CoreFunctions.getConfigSetting(web, "EPMLiveResourceURL", true, false);
if (resUrl != "")
{
try
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
SPWeb resWeb = null;
using (SPSite tempSite = new SPSite(resUrl))
{
resWeb = tempSite.OpenWeb();
if (resWeb != null)
{
SPList list = resWeb.Lists["Resources"];
string[] fields = EPMLiveCore.CoreFunctions.getConfigSetting(web.Site.RootWeb, "EPMLiveTSFields-" + System.IO.Path.GetDirectoryName(list.DefaultView.Url)).Split(',');
SPUser user = web.AllUsers[username];
SPQuery query = new SPQuery();
query.Query = "<Where><Eq><FieldRef Name=\"SharePointAccount\" /><Value Type=\"User\">" + user.Name + "</Value></Eq></Where>";
SPListItem li = list.GetItems(query)[0];
foreach (string field in fields)
{
SPField f = null;
string val = "";
try
{
f = list.Fields.GetFieldByInternalName(field);
if (field.ToLower() == "standardrate")
{
if (!string.IsNullOrEmpty(rate))
{
val = rate;
}
else
{
val = f.GetFieldValueAsText(li[f.Id]);
}
}
else
{
val = f.GetFieldValueAsText(li[f.Id]);
}
}
catch { }
if (f != null)
{
cmd = new SqlCommand("INSERT INTO TSRESMETA (TS_UID,UserName,ColumnName,DisplayName,ColumnValue) VALUES (@TS_UID,@username,@ColumnName,@DisplayName,@ColumnValue)", cn);
cmd.Parameters.AddWithValue("@TS_UID", tsuid);
cmd.Parameters.AddWithValue("@ColumnName", field);
cmd.Parameters.AddWithValue("@UserName", username);
cmd.Parameters.AddWithValue("@DisplayName", f.Title);
cmd.Parameters.AddWithValue("@ColumnValue", val);
cmd.ExecuteNonQuery();
}
}
if (SPContext.Current != null && resWeb.ID != SPContext.Current.Web.ID)
{
resWeb.Close();
}
}
}
});
}
catch { }
}
}
protected override void RenderWebPart(HtmlTextWriter output)
{
if (activation != 0)
{
output.Write(act.translateStatus(activation));
return;
}
if (PropList != "" && PropView != "" && PropStatus != "")
{
try
{
getData();
SPWeb web = SPContext.Current.Web;
SPList list = web.GetListFromUrl(PropList);
SPField field = list.Fields.GetFieldByInternalName(PropStatus);
output.Write("<table border=\"0\" width=\"100%\" cellpadding=\"2\" cellspacing=\"0\">");
foreach (string status in slStatus.Keys)
{
int val = slStatus[status];
int percent = 0;
if (totalItems > 0)
{
percent = val * 100 / totalItems;
}
output.Write("<tr><td class=\"ms-formbody\" width=\"180px\" style=\"vertical-align:middle\">");
string fstatus = "";
try
{
fstatus = field.GetFieldValueAsText(status);
}
catch { }
if (PropUrl != null && PropUrl != "")
{
if (SPContext.Current.Web.ServerRelativeUrl == "/")
{
output.Write("<a href=\"" + PropUrl.Replace("{SiteUrl}", "") + "?filterfield1=" + PropStatus + "&filtervalue1=" + fstatus + "\">");
}
else
{
output.Write("<a href=\"" + PropUrl.Replace("{SiteUrl}", SPContext.Current.Web.ServerRelativeUrl) + "?filterfield1=" + PropStatus + "&filtervalue1=" + fstatus + "\">");
}
}
output.Write(fstatus);
if (PropUrl != "")
{
output.Write("</a>");
}
output.Write(": " + val.ToString() + " ( " + (percent).ToString() + "% ) </td>");
output.Write("<td><table width=\"100%\"><tr><td width=\"" + (percent).ToString() + "%\" height=\"15px\" style=\"background-color: rgb(0, 144, 202)\"></td><td width=\"100%\"></td></tr></table></td></tr>");
}
output.Write("</tr></table>");
}
catch (Exception ex)
{
output.Write("Error: " + ex.Message);
}
}
output.Write(sErrors);
}
public static string TryGetFieldValueAsText(this SPListItem spListItem, dynamic fieldIdentifier)
{
var defaultValue = string.Empty;
SPField field = null;
try
{
if (fieldIdentifier is Guid)
{
if (!spListItem.Fields.Contains((Guid)fieldIdentifier))
{
return(defaultValue);
}
field = spListItem.Fields[(Guid)fieldIdentifier];
}
else if (fieldIdentifier is int)
{
if (spListItem.Fields[(int)fieldIdentifier] == null)
{
return(defaultValue);
}
field = spListItem.Fields[(int)fieldIdentifier];
}
else if (fieldIdentifier is string)
{
if (!spListItem.Fields.ContainsField(fieldIdentifier as string))
{
if (!spListItem.Fields.ContainsFieldWithStaticName(fieldIdentifier as string))
{
return(defaultValue);
}
field = spListItem.Fields.TryGetFieldByStaticName(fieldIdentifier as string);
}
else
{
field = spListItem.Fields.GetField(fieldIdentifier as string);
}
}
if (field == null)
{
return(defaultValue);
}
var value = defaultValue;
if (fieldIdentifier is Guid)
{
value = field.GetFieldValueAsText(spListItem[(Guid)fieldIdentifier]);
}
else if (fieldIdentifier is string)
{
value = field.GetFieldValueAsText(spListItem[fieldIdentifier as string]);
}
else if (fieldIdentifier is int)
{
value = field.GetFieldValueAsText(spListItem[(int)fieldIdentifier]);
}
return(value);
}
catch
{
return(defaultValue);
}
}
private string GetAutoKeywords(string uservalue)
{
StringBuilder content = new StringBuilder();
GetContentFields();
foreach (SPField oField in contentfields)
{
string fieldname = SharePointWebControls.GetFieldName(oField);
if (listItem.Fields.ContainsField(fieldname))
{
try
{
SPField field = listItem.Fields.GetField(fieldname);
string value = field.GetFieldValueAsText(listItem[fieldname]);
//string value = listItem[fieldname] as string;
content.Append(value + " ");
}
catch { };
}
}
WebPartManager webPartManager = WebPartManager.GetCurrentWebPartManager(this.Page);
if (webPartManager != null)
{
foreach (WebPart webpart in webPartManager.WebParts)
{
try
{
IWebPartMetaData data = (IWebPartMetaData)webpart;
if (data != null)
{
content.Append(data.MetaData() + " ");
}
}
catch (Exception ex)
{
ex.ToString();
}
}
}
int providednumber = 0;
if (!String.IsNullOrEmpty(uservalue))
{
providednumber = uservalue.Split(new char[] { ',' }).Length;
}
string clean = HtmlRemoval.StripTagsCharArray(content.ToString());
KeywordAnalyzer analyzer = new KeywordAnalyzer();
KeywordAnalysis analysis = analyzer.Analyze(clean);
int numberleft = (settings.NumberOfkeywords - providednumber);
StringBuilder builder = new StringBuilder();
if (numberleft > 0)
{
keywords = analysis.Keywords.Take(numberleft);
if (!uservalue.EndsWith(","))
{
builder.Append(", ");
}
foreach (Keyword keyword in keywords)
{
builder.AppendFormat("{0}, ", keyword.Word);
}
}
string returnvalue = builder.ToString();
returnvalue = returnvalue.TrimEnd(new char[] { ',', ' ' });
returnvalue = returnvalue.TrimStart(new char[] { ',', ' ' });
return(returnvalue);
}
private void processSite(SPWeb web, string spquery)
{
foreach (string slist in lists)
{
try
{
SPQuery query = new SPQuery();
query.Query = spquery;
//query.ViewFields = view.ViewFields.SchemaXml;
SPList list = web.Lists[slist];
SPListItemCollection colListItems = list.GetItems(query);
int counter = 0;
foreach (SPListItem li in colListItems)
{
string[] fldVals = new string[li.Fields.Count];
DataRow dr = dtRollup.NewRow();
foreach (string strField in arrFields)
{
try
{
if (strField == "Site")
{
dr[strField] = li.ParentList.ParentWeb.Title;
}
else if (strField == "List")
{
dr[strField] = slist;
}
else
{
SPField field = getRealField(li.Fields.GetFieldByInternalName(strField));
if (li[field.Id] != null)
{
string val = li[field.Id].ToString();
try
{
val = field.GetFieldValueAsText(val);
}
catch { }
dr[field.InternalName] = val;
}
}
}
catch { }
//fldVals[counter] = val;
counter += 1;
}
dtRollup.Rows.Add(dr);
}
}
catch { }
}
foreach (SPWeb w in web.Webs)
{
try
{
processSite(w, spquery);
}
catch (Exception ex) { LoggingService.WriteTrace(Area.EPMLiveCore, Categories.EPMLiveCore.Event, TraceSeverity.Medium, ex.ToString()); }
finally
{
if (w != null)
{
w.Dispose();
}
}
}
}
