/// <summary>
/// makes sure that the field can be copied
/// </summary>
/// <param name="fromField"></param>
/// <param name="toField"></param>
/// <returns></returns>
public static bool FieldShouldBeCopiedTo(SPField fromField, SPField toField)
{
if (fromField.Type == toField.Type)
{
if (fromField.Type != SPFieldType.Lookup)
{
if (fromField.Type == SPFieldType.User)
{
SPFieldUser user = fromField as SPFieldUser;
SPFieldUser user2 = toField as SPFieldUser;
if (user.AllowMultipleValues && !user2.AllowMultipleValues)
{
return(false);
}
if ((user2.SelectionMode == SPFieldUserSelectionMode.PeopleOnly) && (user.SelectionMode == SPFieldUserSelectionMode.PeopleAndGroups))
{
return(false);
}
}
return(true);
}
SPFieldLookup lookup = fromField as SPFieldLookup;
SPFieldLookup lookup2 = toField as SPFieldLookup;
if (!(lookup.LookupWebId == lookup2.LookupWebId))
{
return(false);
}
return(lookup.LookupList == lookup2.LookupList);
}
return(false);
}
public List <SPUser> GetUsersFromSPFieldUser(SPListItem item, string filedName)
{
List <SPUser> fUsers = new List <SPUser>();
SPWeb web = item.ParentList.ParentWeb;
SPFieldUser uField = item.Fields[" 作者 "] as SPFieldUser;
if (!uField.AllowMultipleValues) //未允许多重选择
{
SPFieldUserValue userValue = new SPFieldUserValue(web, item[filedName].ToString());
fUsers.Add(userValue.User);
}
else
{
SPFieldUserValueCollection userValues = item[filedName] as SPFieldUserValueCollection;
foreach (SPFieldUserValue userValue in userValues)
{
if (userValue.User != null)
{
fUsers.Add(userValue.User);
}
//else
//{
// SPGroup userGroup = web.SiteGroups.GetByID(userValue.LookupID);
// fUsers.AddRange(userGroup.Users);
//}
}
}
return(fUsers);
}
private SPFieldUserValueCollection GetManagers(SPListItem item)
{
SPFieldUserValueCollection fieldValues = new SPFieldUserValueCollection();
if (item["Responsible"] != null)
{
SPFieldUserValue userValue = new SPFieldUserValue(item.Web, item["Responsible"].ToString());
fieldValues.Add(userValue);
}
SPFieldUser field = item.Fields["Person in charge"] as SPFieldUser;
if (field != null && item["Person in charge"] != null)
{
SPFieldUserValueCollection picFieldValues = field.GetFieldValue(item["Person in charge"].ToString()) as SPFieldUserValueCollection;
fieldValues.AddRange(picFieldValues);
}
if (item["Approver"] != null)
{
SPFieldUserValue userValue = new SPFieldUserValue(item.Web, item["Approver"].ToString());
fieldValues.Add(userValue);
}
string secondApprover = GetSecondApprover(item);
if (secondApprover != string.Empty && item[secondApprover] != null)
{
SPFieldUserValue userValue = new SPFieldUserValue(item.Web, item[secondApprover].ToString());
fieldValues.Add(userValue);
}
return(fieldValues);
}
public ArtDevField CreateFieldUser(string Name)
{
SPFieldUser Field = NewOrRefUser(Name);
ArtDevField ArtDevField = new ArtDevField(Field);
return(ArtDevField);
}
public static SPUser GetFieldAsSPUser(this SPListItem item, Guid userFieldGuid)
{
SPUser user = null;
// Verify that a user field exists
SPFieldUser userField = item.Fields[userFieldGuid] as SPFieldUser;
if (userField != null && item[userFieldGuid] != null)
{
// Convert the user field into an SPUser object
SPFieldUserValue userFieldValue = userField.GetFieldValue(item[userFieldGuid].ToString()) as SPFieldUserValue;
if (userFieldValue != null)
{
user = userFieldValue.User;
}
else
{
Logger.Instance.Error(string.Format("Cannot get user field {0} at {1}", userFieldGuid.ToString(), item.Url), DiagnosticsCategories.eCaseExtensions);
}
}
else
{
Logger.Instance.Error(string.Format("Field with GUID {0} not found in List {1}", userFieldGuid, item.ParentList.RootFolder.Url), DiagnosticsCategories.eCaseExtensions);
}
return(user);
}
/// <summary>
/// 查询SharePoint列表项中用户/用户组栏中的用户（单个用户的字段）
/// </summary>
/// <param name="spItem">列表项</param>
/// <param name="fieldName">栏名</param>
/// <returns></returns>
SPUser GetSPUserFromSPListItemByFieldName(SPListItem spItem, string fieldName)
{
string userName = spItem[fieldName].ToString();
SPFieldUser _user = (SPFieldUser)spItem.Fields[fieldName];
SPFieldUserValue userValue = (SPFieldUserValue)_user.GetFieldValue(userName);
return(userValue.User);
}
public static SPUser GetUser(SPListItem item, SPField userField)
{
string currentValue = item[userField.Title].ToString();
SPFieldUser field = (SPFieldUser)userField;
SPFieldUserValue fieldValue = (SPFieldUserValue)field.GetFieldValue(currentValue);
return(fieldValue.User);
}
public SPFieldUser NewOrRefUser(string Name)
{
string UserName = this.Web().Fields.ContainsField(Name) ? Name : this.Web().Fields.Add(Name, SPFieldType.User, false);
SPFieldUser UserField = (SPFieldUser)this.Web().Fields.GetFieldByInternalName(UserName);
UserField.Group = this.columnGroup;
return(UserField);
}
/// <summary>
/// Public Methods
/// </summary>
/// <param name="listName"></param>
/// <param name="properties"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public string GetSPUserEmailID(string listName, SPItemEventProperties properties, string fieldName)
{
SPFieldUser userField = (SPFieldUser)properties.OpenWeb().Lists[listName].Fields.GetField(fieldName);
SPFieldUserValue fieldValue = (SPFieldUserValue)userField.GetFieldValue(properties.ListItem[fieldName] + "");
SPUser user = fieldValue.User;
return(user.Email);
}
public static void SetFieldAsSPUser(this SPListItem item, Guid userFieldGuid, SPUser user)
{
SPFieldUser userField = item.Fields[userFieldGuid] as SPFieldUser;
if (userField != null && user != null)
{
item[userFieldGuid] = new SPFieldUserValue(item.Web, user.ID, user.Name);
}
}
private string GetItemAuthorId(SPListItem item)
{
// get user object
SPFieldUser author = (SPFieldUser)item.Fields[SPBuiltInFieldId.Author];
SPFieldUserValue userVal = (SPFieldUserValue)author.GetFieldValue(item[SPBuiltInFieldId.Author].ToString());
SPUser authorObj = userVal.User;
return((authorObj == null) ? string.Empty : authorObj.ID.ToString());
}
/// <summary>
/// copies list properties excluding readonly fields and fields that are not present in destination list
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
private static void CopyFieldValues(SPListItem source, SPListItem destination, bool linkToOriginal)
{
foreach (SPField sourceField in source.Fields) // loop thru source item fields
{
if (FieldShouldBeCopied(sourceField)) //can we copy this field?
{
if (destination.Fields.ContainsField(sourceField.Title)) // does a field with same title exists in dest list
{
SPField destField = destination.Fields[sourceField.Title];
if (FieldShouldBeCopied(destField) && FieldShouldBeCopiedTo(sourceField, destField)) // do the field types match?
{
//user lookup ids are not valid when copying items cross site, so we need to create new lookup ids in destination site by calling SPWeb.EnsureUser()
if (sourceField.Type == SPFieldType.User && source[sourceField.Title] != null && source.ParentList.ParentWeb.ID != destination.ParentList.ParentWeb.ID)
{
try
{
SPFieldUser fieldUser = sourceField as SPFieldUser;
if (fieldUser.AllowMultipleValues == false)
{
SPFieldUserValue userValue = new SPFieldUserValue(source.ParentList.ParentWeb, source[sourceField.Title].ToString());
destination[sourceField.Title] = destination.ParentList.ParentWeb.EnsureUser(userValue.User.LoginName);
}
else
{
SPFieldUserValueCollection useValCol = new SPFieldUserValueCollection(source.ParentList.ParentWeb, source[sourceField.Title].ToString());
SPFieldUserValueCollection destValCol = new SPFieldUserValueCollection();
foreach (SPFieldUserValue usr in useValCol)
{
using (SPWeb parentWeb = destination.ParentList.ParentWeb)
{
SPUser destUser = parentWeb.EnsureUser(usr.User.LoginName);
destValCol.Add(new SPFieldUserValue(parentWeb, destUser.ID, string.Empty));
}
}
destination[sourceField.Title] = destValCol;
}
}
catch { }
}
else
{
destination[sourceField.Title] = source[sourceField.Title];
}
}
}
}
}
if (linkToOriginal)
{
destination[ColumnHelper.PublishedFromInternalColumnName] = ListHelper.GetDisplayUrl(source);
}
}
//Mit dieser Methode wird aus den Spalten "Name Besteller" und "Projektleiter" der "SPUser" erhalten; mit diesem kann auf Mail-Adresse und Anzeigename zugegriffen werden
//Sie wird verwendet, um den Anzeigename in der Mail an die Zentrale verwenden zu können
public String GetUserDisplayName(SPListItem listItem, String collumnName)
{
//Laden des userFields aus dem übergebenem Element (listitem) und der Spalte, die einen Nutzer enthält (spalte)
SPFieldUser userField = (SPFieldUser)listItem.Fields.GetField(collumnName);
SPFieldUserValue userFieldValue = (SPFieldUserValue)userField.GetFieldValue(listItem[collumnName].ToString());
SPUser user = userFieldValue.User;
//Zuweisen des Anzeigenamens und Rückgabe desselben
string displayName = user.Name;
return(displayName);
}
public static SPUser GetSPUser(SPListItem item, string key)
{
SPFieldUser field = item.Fields[key] as SPFieldUser;
if (field != null)
{
SPFieldUserValue fieldValue =
field.GetFieldValue(item[key].ToString()) as SPFieldUserValue;
if (fieldValue != null)
{
return(fieldValue.User);
}
}
return(null);
}
public static User ToUserModel(this SPListItem item, string fieldName)
{
SPFieldUser spuserField = (SPFieldUser)item.Fields.GetField(fieldName);
SPFieldUserValue spuserFieldValue = (SPFieldUserValue)spuserField.GetFieldValue(Convert.ToString(item[fieldName]));
User user = new User();
if (spuserFieldValue != null)
{
user.UserName = spuserFieldValue.User.LoginName;
user.FullName = spuserFieldValue.User.Name;
// Duc.VoTan Add
user.ID = spuserFieldValue.LookupId;
}
return(user);
}
/// <summary>
/// Get User from SPField
/// </summary>
private static SPUser GetUser(SPListItem item, SPField userField)
{
SPUser returnUser = null;
try
{
string currentValue = item[userField.Title].ToString();
SPFieldUser field = (SPFieldUser)userField;
SPFieldUserValue fieldValue = (SPFieldUserValue)field.GetFieldValue(currentValue);
returnUser = fieldValue.User;
}
catch
{
Logger.Instance.Error(string.Format("Exception looking for user: {0}", "userField"), DiagnosticsCategories.eCaseSite);
returnUser = null;
}
return(returnUser);
}
private List <SPUser> GetSPUserObject(SPListItem spListItem, String fieldName)
{
List <SPUser> spUser = new List <SPUser>();
try
{
if (fieldName != string.Empty)
{
SPFieldUser field = spListItem.Fields[fieldName] as SPFieldUser;
if (field != null && spListItem[fieldName] != null)
{
SPFieldUserValue fieldValue = field.GetFieldValue(spListItem[fieldName].ToString()) as SPFieldUserValue;
if (fieldValue != null)
{
spUser.Add(fieldValue.User);
}
else
{
SPFieldUserValueCollection fieldValues = field.GetFieldValue(spListItem[fieldName].ToString()) as SPFieldUserValueCollection;
foreach (SPFieldUserValue fv in fieldValues)
{
spUser.Add(fv.User);
}
}
}
else
{
if (field == null)
{
throw new Exception("GetSPUserObject: field is null ");
}
if (spListItem[fieldName] == null)
{
throw new Exception("GetSPUserObject: spListItem[fieldName] is null ");
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(spUser);
}
/// <summary>
/// Assigns the role user to the AUFGABE (Task)
/// </summary>
protected void Button1_Click(object sender, EventArgs e)
{
bool success = true;
SPWeb contextWeb = SPContext.Current.Web;
SPList rollenzuteilung = contextWeb.Lists["Rollenzuteilung"];
foreach (SPListItem item in rollenzuteilung.Items)
{
try
{
String rolle = item["Rolle"].ToString();
if (rolle != null)
{
if (item["Verantwortlich"] != null)
{
SPFieldUser assignedTo = (SPFieldUser)rollenzuteilung.Fields["Verantwortlich"];
SPFieldUserValue user = (SPFieldUserValue)assignedTo.GetFieldValue(item["Verantwortlich"].ToString());
SPUser userObject = user.User;
UpdateAufgabe(rolle, userObject);
UpdateErgebnisse(rolle, userObject);
}
}
}
catch (Exception ex)
{
success = false;
if (Rollenzuteilung_failed_errormessage.Text != ex.Message)
{
Rollenzuteilung_failed_errormessage.Text = Rollenzuteilung_failed_errormessage.Text + " " + ex.Message;
}
}
}
if (success)
{
Rollenzuteilung_erledigt.Visible = true;
}
else
{
Rollenzuteilung_failed.Visible = true;
Rollenzuteilung_failed_errormessage.Visible = true;
}
}
public static IList <User> ToUserModelList(this SPListItem item, string fieldName)
{
SPFieldUser spuserField = (SPFieldUser)item.Fields.GetField(fieldName);
IList <User> UserList = new List <User>();
SPFieldUserValueCollection spuserFieldValueList = (SPFieldUserValueCollection)spuserField.GetFieldValue(Convert.ToString(item[fieldName]));
if (spuserFieldValueList != null)
{
foreach (var userFieldValue in spuserFieldValueList)
{
User user = new User();
user.UserName = userFieldValue.User.LoginName;
user.FullName = userFieldValue.User.Name;
UserList.Add(user);
}
}
return(UserList);
}
public LookupItem GetCurrentEmployeeProcessing(SPListItem listItem)
{
SPFieldUser spuserField = (SPFieldUser)listItem.Fields.GetField(ShiftManagementList.ApprovedByField);
SPFieldUserValue spuserFieldValue = (SPFieldUserValue)spuserField.GetFieldValue(Convert.ToString(listItem[ShiftManagementList.ApprovedByField]));
if (spuserFieldValue != null)
{
EmployeeInfo approver = _employeeInfoDAL.GetByADAccount(spuserFieldValue.LookupId);
string approvalStatus = listItem[listItem.Fields.GetField(CommonSPListField.ApprovalStatusField).Id] + string.Empty;
if (approver != null && IsShiftApproved(listItem.ID) == false)
{
return(new LookupItem {
LookupId = approver.ID, LookupValue = approver.FullName
});
}
}
return(null);
}
private void GetSPUserObject(SPListItem item, String fieldName, SPRoleDefinition roleDefinition)
{
try
{
if (fieldName != string.Empty)
{
SPFieldUser field = item.Fields[fieldName] as SPFieldUser;
if (field != null && item[fieldName] != null)
{
SPFieldUserValue fieldValue = field.GetFieldValue(item[fieldName].ToString()) as SPFieldUserValue;
if (fieldValue != null)
{
AddPermissions(item, fieldValue.User, roleDefinition);
}
else
{
SPFieldUserValueCollection fieldValues = field.GetFieldValue(item[fieldName].ToString()) as SPFieldUserValueCollection;
foreach (SPFieldUserValue fv in fieldValues)
{
AddPermissions(item, fv.User, roleDefinition);
}
}
}
else
{
if (field == null)
{
throw new Exception("GetSPUserObject: field is null ");
}
if (item[fieldName] == null)
{
throw new Exception("GetSPUserObject: spListItem[fieldName] is null ");
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// User object is embedded in the field value as SPUserField object
/// </summary>
/// <param name="item"></param>
/// <param name="field"></param>
/// <returns></returns>
private string GetSPUser(SPListItem item, SPField field)
{
string alias = string.Empty;
// get the FieldUser object
SPFieldUser fieldUser = item.Fields[field.Title] as SPFieldUser;
// get the FieldUserValue object
if (item[field.Title] != null)
{
SPFieldUserValue spUserValue = fieldUser.GetFieldValue(item[field.Title].ToString()) as SPFieldUserValue;
// split out the name if we have one
string[] name = (!string.IsNullOrEmpty(spUserValue.User.Name)) ? spUserValue.User.Name.Split(GlobalConstants.COMMA_DELIMITER) : new string[] { string.Empty, string.Empty };
// sometimes Share Point User does not have full name
string firstName = string.Empty;
string lastName = string.Empty;
if (name.Length == 1)
{
firstName = name[0].Trim();
lastName = name[0].Trim();
}
else
{
firstName = name[1].Trim();
lastName = name[0].Trim();
}
// create a new KPUser object - consider using this?
KPUser kpUser = new KPUser()
{
ID = spUserValue.User.ID,
Alias = spUserValue.User.LoginName,
FirstName = firstName,
LastName = lastName,
Email = spUserValue.User.Email
};
// returning only the name and alias pipe (|) delimited for now
alias = string.Format("{0}|{1}", spUserValue.User.Name, kpUser.Alias.Split('\\')[1]);
}
return(alias);
}
static void TestLookupFields(SPWeb spWeb)
{
SPList
//list = spWeb.Lists["Внутрішні документи"];
//list = spWeb.Lists["Підрозділ організації"];
list = spWeb.Lists["Рух вхідних документів"];
SPListItem
item = list.Items[0];
string
fieldName = "dn_ct_Recipient";
SPField
//field = item.Fields.GetFieldByInternalName("dn_ct_AuthorExecutor");
//field = item.Fields["Автор-виконавець"];
field = item.Fields.GetFieldByInternalName(fieldName);
object tmpObject = item[fieldName];
SPField spField = item[fieldName] as SPField;
SPFieldLookup spFieldLookup = item[fieldName] as SPFieldLookup;
SPFieldLookupValue spFieldLookupValue = item[fieldName] as SPFieldLookupValue;
SPFieldUser spFieldUser = item[fieldName] as SPFieldUser;
SPFieldUserValue spFieldUserValue = item[fieldName] as SPFieldUserValue;
if ((spFieldUserValue = field.GetFieldValue(tmpObject.ToString()) as SPFieldUserValue) != null)
{
Console.WriteLine("LookupId: {0}", spFieldUserValue.LookupId);
}
SPFieldUserValueCollection spFieldUserValueCollection = item[fieldName] as SPFieldUserValueCollection;
if ((spFieldUserValueCollection = field.GetFieldValue(tmpObject.ToString()) as SPFieldUserValueCollection) != null)
{
foreach (SPFieldUserValue _spFieldUserValue_ in spFieldUserValueCollection)
{
Console.WriteLine("LookupId: {0}, LookupValue: {1}, User.ID: {2}, User.Name: {3}", _spFieldUserValue_.LookupId, _spFieldUserValue_.LookupValue, _spFieldUserValue_.User.ID, _spFieldUserValue_.User.Name);
}
}
}
private string GetSPUserObject(SPListItem sourceItem, String fieldName)
{
try
{
string emails = string.Empty;
if (fieldName != string.Empty)
{
SPFieldUser field = sourceItem.Fields[fieldName] as SPFieldUser;
if (field != null && sourceItem[fieldName] != null)
{
SPFieldUserValue fieldValue = field.GetFieldValue(sourceItem[fieldName].ToString()) as SPFieldUserValue;
if (fieldValue != null)
{
emails = fieldValue.User.Email + ";";
}
else
{
SPFieldUserValueCollection fieldValues = field.GetFieldValue(sourceItem[fieldName].ToString()) as SPFieldUserValueCollection;
foreach (SPFieldUserValue fv in fieldValues)
{
emails += fv.User.Email + ";";
}
}
}
else
{
if (field == null)
{
throw new Exception("GetSPUserObject: field is null ");
}
}
}
return(emails);
}
catch (Exception ex)
{
throw ex;
}
}
private List <SPUser> GetManagerProd(SPListItem sourceItem, String fieldName)
{
try
{
List <SPUser> allManagers = new List <SPUser>();
if (fieldName != string.Empty)
{
SPFieldUser field = sourceItem.Fields[fieldName] as SPFieldUser;
if (field != null && sourceItem[fieldName] != null)
{
SPFieldUserValue fieldValue = field.GetFieldValue(sourceItem[fieldName].ToString()) as SPFieldUserValue;
if (fieldValue != null)
{
allManagers.Add(fieldValue.User);
}
else
{
SPFieldUserValueCollection fieldValues = field.GetFieldValue(sourceItem[fieldName].ToString()) as SPFieldUserValueCollection;
foreach (SPFieldUserValue fv in fieldValues)
{
allManagers.Add(fv.User);
}
}
}
else
{
if (field == null)
{
throw new Exception("GetManager: field is null ");
}
}
}
return(allManagers);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>Returns all files for an assignment grouped by learner.</summary>
/// <param name="assignmentKey">The key of the assignment.</param>
public Dictionary <string, List <SPFile> > AllFiles(long assignmentKey)
{
string queryXml = @"<Where>
<And>
<Eq><FieldRef Name='{0}'/><Value Type='Text'>{1}</Value></Eq>
<Eq><FieldRef Name='{2}'/><Value Type='Boolean'>1</Value></Eq>
</And>
</Where>";
queryXml = string.Format(CultureInfo.InvariantCulture, queryXml, ColumnAssignmentId, assignmentKey, ColumnIsLatest);
SPQuery query = new SPQuery();
query.ViewAttributes = "Scope=\"Recursive\"";
query.Query = queryXml;
SPListItemCollection items = DropBoxList.GetItems(query);
SPFieldUser learnerField = (SPFieldUser)DropBoxList.Fields[ColumnLearner];
Dictionary <string, List <SPFile> > files = new Dictionary <string, List <SPFile> >();
foreach (SPListItem item in items)
{
SPFile file = item.File;
SPFieldUserValue learnerValue = (SPFieldUserValue)learnerField.GetFieldValue(item[ColumnLearner].ToString());
SPUser learner = learnerValue.User;
List <SPFile> learnerFiles;
string learnerAccount = learner.LoginName.Replace("\\", "-");
if (files.TryGetValue(learnerAccount, out learnerFiles) == false)
{
learnerFiles = new List <SPFile>();
files.Add(learnerAccount, learnerFiles);
}
learnerFiles.Add(item.File);
}
return(files);
}
public static void CreateUserColumn(this SPWeb web, string group, string description, string name, string displayName)
{
try
{
if (!web.Fields.ContainsField(name))
{
string fieldName = web.Fields.Add(name, SPFieldType.User, false);
SPFieldUser field = (SPFieldUser)web.Fields.GetField(name);
field.Group = group;
field.StaticName = name;
field.Title = displayName;
field.NoCrawl = false;
field.Description = description;
field.Update();
}
}
catch (Exception ex)
{
SPDiagnosticsService.Local.WriteTrace(0, new SPDiagnosticsCategory("CORE:HELPERS", TraceSeverity.Unexpected, EventSeverity.Error), TraceSeverity.Unexpected, String.Format("Exception happened in Helpers:CreateUserColumn. MESSAGE: {0}. EXCEPTION TRACE: {1} ", ex.Message, ex.StackTrace), ex.StackTrace);
}
}
public QueryControlUser(SPField f)
{
_Field = (SPFieldUser)f;
}
private static void updateFromAD(Dictionary <string, Guid> indexedTaxonomy, TermSet termSet, string ldapServerUrl, string principalCID, SPListItem item, SPFieldUser staffUserId)
{
var chalmerUserId = staffUserId.GetFieldValue(item[Constants.ChalmersID].ToString()) as SPFieldUserValue;
if (chalmerUserId != null)
{
string username = chalmerUserId.User.LoginName;
LoggingService.WriteTrace(EventSeverity.Information, "Got username: "******"UserLoginName has claims: " + userLoginName, LogCategory.ChalmersPublicWeb);
}
if (!string.IsNullOrEmpty(userLoginName))
{
ADuser aduser = new ADuser(userLoginName)
{
LdapServerUrl = ldapServerUrl,
GivenName = string.Empty,
SN = string.Empty,
Mail = string.Empty,
Organisation = string.Empty,
TelephoneNumber = string.Empty,
OtherTelephone = string.Empty
};
#if DEBUG
string value = ConfigurationFile.GetGonfigurationFile(Chalmers.PublicWeb.Core.Constants.ConfigurationFilePath).GetSettingValue("StaffSyncCID");
if (value.ToLower().Contains(aduser.CID.ToLower().Replace("net\\", string.Empty)))
{
string x = "asdf";
System.Diagnostics.Debug.Print(x.ToString());
}
#endif
LoggingService.WriteTrace(EventSeverity.Information, "aduser CID = " + aduser.CID, LogCategory.ChalmersPublicWeb);
string domain = WebConfigurationManager.AppSettings["CurrentDomain"];
if (string.IsNullOrEmpty(domain))
{
aduser.ADDomainName = @"net\";
}
else
{
aduser.ADDomainName = domain + @"\";
}
if (aduser.CID.IndexOf(@"\", StringComparison.OrdinalIgnoreCase) > 0)
{
aduser.CIDWithoutDomain = aduser.CID.Remove(0, aduser.CID.IndexOf(@"\", StringComparison.OrdinalIgnoreCase) + 1);
#if DEBUG
if (aduser.CIDWithoutDomain.ToString().ToLower().Equals("kain") ||
aduser.CIDWithoutDomain.ToString().ToLower().Equals("anderska"))
{
string x = aduser.CIDWithoutDomain.ToString();
System.Diagnostics.Debug.Print(x);
}
#endif
}
List <Term> terms = null;
TaxonomyField managedField = null;
aduser = ADUserProfile.GetUserProfileFromAD(aduser);
if (aduser != null)
{
bool adUnitsHaveChanged = taxFieldChanged(indexedTaxonomy, termSet, item, aduser, ref terms, ref managedField);
System.Text.StringBuilder phoneNumbers = new System.Text.StringBuilder();
if (!string.IsNullOrEmpty(aduser.TelephoneNumber))
{
phoneNumbers.Append(aduser.TelephoneNumber);
}
if (phoneNumbers.Length > 0 && !string.IsNullOrEmpty(aduser.OtherTelephone))
{
phoneNumbers.Append(", ");
}
if (!string.IsNullOrEmpty(aduser.OtherTelephone))
{
phoneNumbers.Append(aduser.OtherTelephone);
}
if (
hasUpdatedValues(item, aduser, phoneNumbers) ||
DateTime.Now.DayOfWeek == DayOfWeek.Saturday ||
adUnitsHaveChanged ||
(aduser.CID.Equals(principalCID))
)
{
item["EduPersonOrcid"] = aduser.EduPersonOrcid;
item["FieldStaffGivenname"] = aduser.GivenName;
item["FieldStaffLastName"] = aduser.SN;
item["FieldStaffFullName"] = aduser.GivenName + " " + aduser.SN;
item["Title"] = aduser.GivenName + " " + aduser.SN;
item["FieldStaffOrganisation"] = aduser.Organisation;
item["FieldStaffTelephone"] = phoneNumbers.ToString();
item["OfficeRoomNumber"] = aduser.OfficeRoomNumber;
item["OfficeStreet"] = aduser.OfficeStreet;
item["OfficeFloorNumber"] = aduser.OfficeFloorNumber;
setEmail(principalCID, item, aduser);
if (adUnitsHaveChanged)
{
if (terms == null)
{
terms = new List <Term>();
}
managedField.SetFieldValue(item, terms);
}
trySaveChanges(item, aduser);
}
}
}
}
}
private static void CreateMetadataPair(List <GuidewireWS.trg_MetadataPair> metadata, string key, string propertyName, SPListItem item)
{
try
{
GuidewireWS.trg_MetadataPair metadataPair = new GuidewireWS.trg_MetadataPair();
//SPListItem listItem = properties.ListItem;
SPListItem listItem = item;
if (listItem.Fields.ContainsField(propertyName))
{
metadataPair.key = key;
SPField propertyField = listItem.Fields[propertyName];
switch (propertyField.Type)
{
case SPFieldType.User:
{
SPFieldUser userField = propertyField as SPFieldUser;
SPFieldUserValue userFieldValue = (SPFieldUserValue)userField.GetFieldValue(listItem[propertyName].ToString());
if (userFieldValue != null && userFieldValue.User != null)
{
metadataPair.value = userFieldValue.User.Name;
}
else
{
metadataPair.value = (string)listItem[propertyName];
}
}
break;
case SPFieldType.Lookup:
{
SPFieldLookup lookupField = propertyField as SPFieldLookup;
SPFieldLookupValue lookupFieldValue = (SPFieldLookupValue)lookupField.GetFieldValue(listItem[propertyName].ToString());
if (lookupFieldValue != null && lookupFieldValue.LookupValue != null)
{
metadataPair.value = lookupFieldValue.LookupValue;
}
}
break;
// Bamboo selectors have type of invalid but work like lookup
case SPFieldType.Invalid:
{
if (listItem[propertyName] != null)
{
if (propertyField.TypeAsString == "BusinessData")
{
metadataPair.value = (string)listItem[propertyName];
}
else
{
SPFieldLookup lookupField = propertyField as SPFieldLookup;
SPFieldLookupValue lookupFieldValue = (SPFieldLookupValue)lookupField.GetFieldValue(listItem[propertyName].ToString());
if (lookupFieldValue != null && lookupFieldValue.LookupValue != null)
{
metadataPair.value = lookupFieldValue.LookupValue;
}
}
}
}
break;
case SPFieldType.DateTime:
{
metadataPair.value = listItem[propertyName].ToString();
}
break;
default:
if (listItem[propertyName] != null)
{
if (propertyName == "Name")
{
String fileName = (string)listItem[propertyName];
if (fileName.Length > 80)
{
String extension = fileName.Substring(fileName.LastIndexOf("."));
String name = fileName.Substring(0, fileName.Length - extension.Length);
fileName = name.Substring(0, 80 - extension.Length) + extension;
}
metadataPair.value = fileName;
}
else
{
metadataPair.value = (string)listItem[propertyName];
}
}
break;
}
metadata.Add(metadataPair);
}
}
catch (Exception e)
{
LogError("CreateMetadataPair failed with exception: " + e.Message);
}
}
string GetUserEmailFromField(string strUserFieldValue, SPField personOrGroupField)
{
string emailAddressToReturn = string.Empty;
if (!string.IsNullOrEmpty(strUserFieldValue) && strUserFieldValue.Contains(";#"))
{
if (personOrGroupField != null &&
personOrGroupField.Type == SPFieldType.User)
{
try
{
SPFieldUser userField = (SPFieldUser)personOrGroupField;
if (userField != null)
{
if (userField.AllowMultipleValues)
{
SPFieldUserValueCollection userFieldValueColl = (SPFieldUserValueCollection)userField.GetFieldValue(strUserFieldValue);
if (userFieldValueColl != null &&
userFieldValueColl.Count > 0)
{
foreach (SPFieldUserValue userValue in userFieldValueColl)
{
SPUser spUser = userValue.User;
if (spUser != null &&
!string.IsNullOrEmpty(spUser.Email))
{
if (!string.IsNullOrEmpty(emailAddressToReturn))
{
if (!emailAddressToReturn.Contains(spUser.Email))
{
emailAddressToReturn = emailAddressToReturn + "," + spUser.Email;
}
}
else
{
emailAddressToReturn = spUser.Email;
}
}
}
}
}
else
{
SPFieldUserValue userFieldValue = (SPFieldUserValue)userField.GetFieldValue(strUserFieldValue);
if (userFieldValue != null)
{
SPUser spUser = userFieldValue.User;
if (spUser != null &&
!string.IsNullOrEmpty(spUser.Email))
{
emailAddressToReturn = spUser.Email;
}
}
}
}
}
catch { }
}
}
return(emailAddressToReturn);
}
