public async Task <IActionResult> Update(string Id)
{
if (Id == null)
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(Id);
if (user == null)
{
return(NotFound());
}
var model = new ChangeInformation()
{
Id = user.Id,
Email = user.Email,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
IsActive = user.IsActive,
ProfileImageUrl = user.ProfileImageUrl
//Department = user.DepartmentId,
};
return(View(model));
}
private ChangeInformation GetChangeInf(List <Log> cloudLog, DateTime lastCommitTime, string foodName)
{
ChangeInformation changeInf = new ChangeInformation();
changeInf.FoodName = foodName;
int[] arr = { 0, 0, 0, 0, 0, 0 };
changeInf.Weight = new List <List <int> >(9);
for (int i = 0; i < 9; i++)
{
List <int> weight = new List <int>(arr);
changeInf.Weight.Add(weight);
}
for (int i = 0; i < cloudLog.Count; i++)
{
if (cloudLog[i].Date < lastCommitTime)
{
continue;
}
else if (foodName == cloudLog[i].FoodName)
{
int changePos = 3 * cloudLog[i].WeatherList[0] + cloudLog[i].WeatherList[1];
for (int j = 0; j < 6; j++)
{
changeInf.Weight[changePos][j] =
changeInf.Weight[changePos][j] + cloudLog[i].WeightChangeList[j];
}
}
}
return(changeInf);
}
public async Task <IActionResult> ChangeInformation(ChangeInformation changeInformation)
{
ViewBag.DepartmentList = _regencyService.GetAll().ToList();
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(changeInformation.Id);
string roorPath = _hostingEnviroment.WebRootPath;
var files = HttpContext.Request.Form.Files;
var supportedTypes = new[] { ".jpg", ".jpeg", ".png" };
if (files.Count != 0)
{
var uploads = Path.Combine(roorPath, SD.FolderDefault + "/" + SD.FolderImages + "/" + SD.pathProfiles);
var extension = Path.GetExtension(files[0].FileName).ToLower();
using (var filestream = new FileStream(Path.Combine(uploads, changeInformation.Id + extension), FileMode.Create))
{
files[0].CopyTo(filestream);
}
if (!supportedTypes.Contains(extension))
{
StatusMessage = "Định dạng file không hợp lệ !";
return(RedirectToAction("Update", "Account", new{ Id = changeInformation.Id }));
}
else
{
user.ProfileImageUrl = changeInformation.Id + extension;
}
}
user.Email = changeInformation.Email;
user.IsActive = changeInformation.IsActive;
user.PhoneNumber = changeInformation.PhoneNumber;
user.RegencyId = changeInformation.Regency;
user.Gender = changeInformation.Gender;
// user.DayOfBirth = changeInformation.DataOfBirth.ConvertDateTime();
var userRoles = await _userManager.GetRolesAsync(user);
var resultRemote = await _userManager.RemoveFromRolesAsync(user, userRoles);
if (!resultRemote.Succeeded)
{
ModelState.AddModelError("", resultRemote.Errors.ToString());
}
var result = await _userManager.AddToRoleAsync(user, changeInformation.Role);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.ToString());
}
StatusMessage = "User Updated Successfully. ";
return(RedirectToAction("Index"));
}
return(View(nameof(Update)));
}
public async Task <ChangeInformation> GetTimeTableChanges()
{
var result = new ChangeInformation();
var changes = new List <ChangeInformationItem>();
var client = new HttpClient();
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("pass", "morgen"));
var response = await client.PostAsync("http://new.gym-kahla.de/vertretungsplan/", new FormUrlEncodedContent (postData));
var res = await response.Content.ReadAsStringAsync();
var parser = new HtmlParser();
var doc = parser.Parse(res);
var dateSpan = doc.All.Where(m => m.ClassList.Contains("vpfuerdatum")).First();
result.Date = this.GetDate(dateSpan.TextContent);
return(result);
}
private DateTime GetChangeTimeForTermStore()
{
TermStore clientTermStore = this.connector.FetchClientTermStore(SampleData.TermStoreId);
var changeInformation = new ChangeInformation(this.connector.ClientContext);
changeInformation.WithinTimeSpan = TimeSpan.FromMinutes(1.0);
var changes = clientTermStore.GetChanges(changeInformation);
this.connector.ClientContext.Load(changes, c => c.Include(x => x.ChangedTime));
this.connector.ClientContext.ExecuteQuery();
var maxChange = changes.ToList().LastOrDefault();
if (maxChange == null)
{
return(DateTime.MinValue);
}
return(maxChange.ChangedTime);
}
public async Task <IActionResult> ChangeInformation(ChangeInformation changeInformation)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(changeInformation.Id);
string roorPath = _hostingEnviroment.WebRootPath;
var files = HttpContext.Request.Form.Files;
var supportedTypes = new[] { ".jpg", ".jpeg", ".png" };
if (files.Count != 0)
{
var uploads = Path.Combine(roorPath, SD.FolderDefault + "/" + SD.FolderImages + "/" + SD.pathProfiles);
var extension = Path.GetExtension(files[0].FileName).ToLower();
using (var filestream = new FileStream(Path.Combine(uploads, changeInformation.Id + extension), FileMode.Create))
{
files[0].CopyTo(filestream);
}
if (!supportedTypes.Contains(extension))
{
TempData["Message"] = "Định dạng file không hợp lệ !";
return(RedirectToAction("Update", "Account", new{ Id = changeInformation.Id }));
}
else
{
user.ProfileImageUrl = changeInformation.Id + extension;
}
}
user.Email = changeInformation.Email;
user.IsActive = changeInformation.IsActive;
user.PhoneNumber = changeInformation.PhoneNumber;
TempData["Message"] = "User Updated Successfully. ";
return(RedirectToAction("Index", "Home"));
}
return(View(nameof(Update)));
}
//Update Account
public async Task <IActionResult> Update(string Id)
{
if (Id == null)
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(Id);
if (user == null)
{
return(NotFound());
}
var userRoles = await _userManager.GetRolesAsync(user);
ViewBag.DepartmentList = _regencyService.GetAll().ToList();
var model = new ChangeInformation()
{
Id = user.Id,
Email = user.Email,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
IsActive = user.IsActive,
Gender = user.Gender,
IsLock = user.LockoutEnabled,
DataOfBirth = user.DayOfBirth.ToDate(),
ProfileImageUrl = user.ProfileImageUrl,
Regency = user.RegencyId,
RolesList = _roleManager.Roles.ToList().Select(x => new SelectListItem()
{
Selected = userRoles.Contains(x.Name),
Text = x.Name,
Value = x.Name
})
};
return(View(model));
}
public async Task <IActionResult> ChangeInformation(ChangeInformation changeInformation)
{
if (!ModelState.IsValid)
{
return(new JsonResult("BadRequest"));
}
var basicToken = Request.Headers["Authorization"].ToString();
var token = basicToken.Replace("Basic ", "");
var existToken = _context.Credential.SingleOrDefault(a => a.AccessToken == token);
if (existToken != null)
{
var existAccount = _context.Account.SingleOrDefault(i => i.Id == existToken.OwnerId);
if (existAccount != null)
{
if (existAccount.Phone != null)
{
var address = changeInformation.NewAddress;
existAccount.Address = address;
var phone = changeInformation.Phone;
existAccount.Phone = phone;
var avatar = changeInformation.Avatar;
existAccount.Avartar = avatar;
_context.Account.Update(existAccount);
_context.SaveChanges();
Response.StatusCode = (int)HttpStatusCode.OK;
return(new JsonResult(existAccount));
}
}
return(new JsonResult(existAccount));
}
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(new JsonResult("Forbidden"));
}
public async System.Threading.Tasks.Task MaintenanceAsync()
{
List <Log> localLog = _logService.GetLogs();
if (localLog == null)
{
localLog = new List <Log>();
}
List <Log> cloudLog = await _oneDriveService.LoadLogAsync();
DateTime lastCommitTime = await _lastTimeCommitService.ReadJsonAsync();
if (lastCommitTime == null)
{
lastCommitTime = DateTime.Now;
}
List <FoodWeightChange> totalWeight = await _oneDriveService.LoadFoodWeightAsync();
if (totalWeight.Count == 0)
{
List <FoodInformation> foodInformations = _recommendationService.GetFoodInfs();
for (int i = 0; i < foodInformations.Count; i++)
{
FoodWeightChange foodWeightChange = new FoodWeightChange();
foodWeightChange.FoodName = foodInformations[i].Name;
int[] arr = { 0, 0, 0, 0, 0, 0 };
List <int> reasonList = new List <int>(arr);
foodWeightChange.weightChangeList = reasonList;
totalWeight.Add(foodWeightChange);
}
}
// bug
var foodInformationList = _recommendationService.GetFoodInfs();
for (int i = 0; i < foodInformationList.Count; i++)
{
var FoodName = foodInformationList[i].Name;
ChangeInformation cloudChangeInfList = GetChangeInf(cloudLog, lastCommitTime, FoodName);
ChangeInformation localChangeInfList = GetChangeInf(localLog, lastCommitTime, FoodName);
int[] arr = { 0, 0, 0, 0, 0, 0 };
List <int> tmpWeightChangeList = totalWeight[i].weightChangeList;
for (int j = 0; j < 9; j++)
{
int flag = 0;
for (int k = 0; k < 6; k++)
{
if (cloudChangeInfList.Weight[j][k] >= 0 && localChangeInfList.Weight[j][k] >= 0)
{
if (cloudChangeInfList.Weight[j][k] >= localChangeInfList.Weight[j][k])
{
//tmpWeightChangeList[k] = tmpWeightChangeList[k] + cloudChangeInfList.Weight[j][k];
tmpWeightChangeList[k] = tmpWeightChangeList[k];
continue;
}
else if (cloudChangeInfList.Weight[j][k] < localChangeInfList.Weight[j][k])
{
if (flag == 0)
{
cloudLog = DeleteRecord(cloudLog, FoodName, lastCommitTime, j);
cloudLog = InsertRecord(cloudLog, localLog, FoodName, lastCommitTime, j);
flag = 1;
for (int m = 0; m < 6; m++)
{
tmpWeightChangeList[m] = tmpWeightChangeList[m] - cloudChangeInfList.Weight[j][m] + localChangeInfList.Weight[j][m];
}
}
}
}
else if (cloudChangeInfList.Weight[j][k] <= 0 && localChangeInfList.Weight[j][k] <= 0)
{
if (cloudChangeInfList.Weight[j][k] <= localChangeInfList.Weight[j][k])
{
tmpWeightChangeList[k] = tmpWeightChangeList[k];
continue;
}
else if (cloudChangeInfList.Weight[j][k] > localChangeInfList.Weight[j][k])
{
if (flag == 0)
{
cloudLog = DeleteRecord(cloudLog, FoodName, lastCommitTime, j);
cloudLog = InsertRecord(cloudLog, localLog, FoodName, lastCommitTime, j);
flag = 1;
for (int m = 0; m < 6; m++)
{
tmpWeightChangeList[m] = tmpWeightChangeList[m] - cloudChangeInfList.Weight[j][m] + localChangeInfList.Weight[j][m];
}
}
}
}
else
{
if (flag == 0)
{
cloudLog = InsertRecord(cloudLog, localLog, FoodName, lastCommitTime, j);
flag = 1;
for (int m = 0; m < 6; m++)
{
tmpWeightChangeList[m] = tmpWeightChangeList[m] + localChangeInfList.Weight[j][m];
}
}
}
}
}
_foodFavorService.SetWeight(i, tmpWeightChangeList);
}
localLog = cloudLog;
_logService.SetLogs(cloudLog);
_logService.SaveLogAsync();
_foodFavorService.SaveChangeWeightAsync();
lastCommitTime = DateTime.Now;
_lastTimeCommitService.SaveJsonAsync(lastCommitTime);
}
/// <summary>
/// Processes the change log from the source term store and applies the changes to the target termstore
/// </summary>
/// <param name="sourceClientContext">ClientContext of the source SharePoint site</param>
/// <param name="targetClientContext">ClientContext of the target SharePoint site</param>
/// <param name="startFrom">DateTime object indicating from which date/time we would like to process the changelog</param>
/// <param name="termGroupExclusions">Optional parameter that shows the termgroups that are excluded from processing</param>
/// <param name="termSetInclusions">Optional parameter that shows the termsets that exclusively processed, others are skipped if this is defined</param>
/// <returns>True if successful, false otherwise</returns>
public bool ProcessChanges(ClientContext sourceClientContext, ClientContext targetClientContext, DateTime startFrom, List<string> termGroupExclusions = null, List<string> termSetInclusions = null)
{
Log.Internal.TraceInformation((int)EventId.TaxonomySession_Open, "Opening the taxonomy session");
TaxonomySession sourceTaxonomySession = TaxonomySession.GetTaxonomySession(sourceClientContext);
TermStore sourceTermStore = sourceTaxonomySession.GetDefaultKeywordsTermStore();
sourceClientContext.Load(sourceTermStore,
store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
sourceClientContext.ExecuteQuery();
Log.Internal.TraceInformation((int)EventId.TermStore_GetChangeLog, "Reading the changes");
ChangeInformation changeInformation = new ChangeInformation(sourceClientContext);
changeInformation.StartTime = startFrom;
ChangedItemCollection termStoreChanges = sourceTermStore.GetChanges(changeInformation);
sourceClientContext.Load(termStoreChanges);
sourceClientContext.ExecuteQuery();
if (termStoreChanges.Count > 0)
{
Log.Internal.TraceInformation((int)EventId.TermStore_NumberOfChanges, "Number of changes returned: {0}", termStoreChanges.Count);
bool noError = true;
// Load up the taxonomy item names.
TaxonomySession targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
TermStore targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore,
store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.ExecuteQuery();
List<int> languagesToProcess = null;
if (!ValidTermStoreLanguages(sourceTermStore, targetTermStore, out languagesToProcess))
{
Log.Internal.TraceError((int)EventId.LanguageMismatch, "The target termstore default language {0} is not available as language in the source term store, syncing cannot proceed.");
return false;
}
foreach (ChangedItem _changeItem in termStoreChanges)
{
//sometimes we get stale entries, code should handle them but for performance reasons it's better to filter them out
if (_changeItem.ChangedTime < startFrom)
{
Log.Internal.TraceVerbose((int)EventId.TermStore_SkipChangeLogEntry, "Skipping item {1} changed at {0}", _changeItem.ChangedTime, _changeItem.Id);
continue;
}
Log.Internal.TraceVerbose((int)EventId.TermStore_ProcessChangeLogEntry, "Processing item {1} changed at {0}. Operation = {2}, ItemType = {3}", _changeItem.ChangedTime, _changeItem.Id, _changeItem.Operation, _changeItem.ItemType);
#region Group changes
if (_changeItem.ItemType == ChangedItemType.Group)
{
#region Delete group
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (!targetTermGroup.ServerObjectIsNull.Value)
{
if (termGroupExclusions == null || !termGroupExclusions.Contains(targetTermGroup.Name, StringComparer.InvariantCultureIgnoreCase))
{
Log.Internal.TraceInformation((int)EventId.TermGroup_Delete, "Deleting group: {0}", targetTermGroup.Name);
targetTermGroup.DeleteObject();
targetClientContext.ExecuteQuery();
}
}
}
#endregion
else
{
TermGroup sourceTermGroup = sourceTermStore.GetGroup(_changeItem.Id);
sourceClientContext.Load(sourceTermGroup, group => group.Name,
group => group.Id,
group => group.IsSystemGroup,
group => group.Description);
sourceClientContext.ExecuteQuery();
if (sourceTermGroup.ServerObjectIsNull.Value)
{
//source group not found...can happen is SharePoint is sending stale entries in the changelog (or when too old entries are requested)
continue;
}
else
{
if (sourceTermGroup.IsSystemGroup)
{
Log.Internal.TraceInformation((int)EventId.TermGroup_IsSystemGroup, "Group {0} is a system group", sourceTermGroup.Name);
continue;
}
}
#region Add group
if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup, group => group.Name,
group => group.Id);
targetClientContext.ExecuteQuery();
// If group already exists no action is needed
if (targetTermGroup.ServerObjectIsNull.Value)
{
TermGroup targetTermGroupTest = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroupTest, group => group.Name);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermGroupTest.ServerObjectIsNull.Value)
{
if (sourceTermGroup.Name.ToLower() == "system" || sourceTermGroup.Name.ToLower() == "people")
{
Log.Internal.TraceInformation((int)EventId.TermGroup_AlreadyExists, "Group {0} already exists", sourceTermGroup.Name);
continue;
}
else
{
InvalidOperationException uEx = new InvalidOperationException(String.Format("A group named {0} already exists but with a different ID. Please delete the term group from the target termstore", sourceTermGroup.Name));
Log.Internal.TraceError((int)EventId.TermGroup_IDMismatch, uEx, "A group named {0} already exists but with a different ID. Please delete the term group from the target termstore", sourceTermGroup.Name);
break;
}
}
}
catch
{
}
if (termGroupExclusions == null || !termGroupExclusions.Contains(sourceTermGroup.Name, StringComparer.InvariantCultureIgnoreCase))
{
Log.Internal.TraceInformation((int)EventId.TermGroup_Add, "Adding group {0}", sourceTermGroup.Name);
TermGroup _targetTermGroup = targetTermStore.CreateGroup(sourceTermGroup.Name, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTermGroup.Description))
{
_targetTermGroup.Description = sourceTermGroup.Description;
}
targetClientContext.ExecuteQuery();
}
}
}
#endregion
#region Edit group
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup, group => group.Name,
group => group.Id);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
if (termGroupExclusions == null || !termGroupExclusions.Contains(sourceTermGroup.Name, StringComparer.InvariantCultureIgnoreCase))
{
Log.Internal.TraceInformation((int)EventId.TermGroup_Edit, "Modifying group: {0}", sourceTermGroup.Name);
targetTermGroup.Name = sourceTermGroup.Name;
if (!string.IsNullOrEmpty(sourceTermGroup.Description))
{
targetTermGroup.Description = sourceTermGroup.Description;
}
targetClientContext.ExecuteQuery();
}
}
#endregion
}
}
#endregion
#region TermSet changes
if (_changeItem.ItemType == ChangedItemType.TermSet)
{
#region Delete termset
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermSet targetTermset = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermset);
targetClientContext.ExecuteQuery();
if (!targetTermset.ServerObjectIsNull.Value)
{
//Check if the termset is in the group we're processing. If the termset inclusion list is not set then this will just return true
if (IsTermSetInIncludedTermSets(targetClientContext, targetTermset, termSetInclusions))
{
if (IsTermSetInExcludedGroup(targetClientContext, targetTermset, termGroupExclusions))
{
Log.Internal.TraceInformation((int)EventId.TermSet_Skip, "Skip termset {0} due to included in excluded group", targetTermset.Name);
continue;
}
}
else
{
Log.Internal.TraceInformation((int)EventId.TermSet_Skip_Inclusion, "Skip termset {0} due to not included in termset inclusion group", targetTermset.Name);
continue;
}
Log.Internal.TraceInformation((int)EventId.TermSet_Delete, "Deleting termset {0}", targetTermset.Name);
targetTermset.DeleteObject();
targetClientContext.ExecuteQuery();
}
}
#endregion
else
{
TermSet sourceTermset = sourceTermStore.GetTermSet(_changeItem.Id);
sourceClientContext.Load(sourceTermset, termset => termset.Name,
termset => termset.Id,
termset => termset.Description,
termset => termset.Contact,
termset => termset.CustomProperties,
termset => termset.IsAvailableForTagging,
termset => termset.IsOpenForTermCreation,
termset => termset.CustomProperties,
termset => termset.Terms, terms => terms.Id, terms => terms.Name, terms => terms.Description,
termset => termset.Group, group => group.Id);
sourceClientContext.ExecuteQuery();
if (sourceTermset.ServerObjectIsNull.Value)
{
continue;
}
else
{
//Check if the termset is in the group we're processing. If the termset inclusion list is not set then this will just return true
if (IsTermSetInIncludedTermSets(sourceClientContext, sourceTermset, termSetInclusions))
{
//Check if the termset is not in a group we're not processing
if (IsTermSetInExcludedGroup(sourceClientContext, sourceTermset, termGroupExclusions))
{
Log.Internal.TraceInformation((int)EventId.TermSet_Skip, "Skip termset {0} due to included in excluded group", sourceTermset.Name);
continue;
}
}
else
{
Log.Internal.TraceInformation((int)EventId.TermSet_Skip_Inclusion, "Skip termset {0} due to not included in termset inclusion group", sourceTermset.Name);
continue;
}
}
#region Move termset
if (_changeItem.Operation == ChangedOperationType.Move)
{
TermSet targetTermSetCheck = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermSetCheck, termset => termset.Name,
termset => termset.Group, group => group.Id);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermSetCheck.ServerObjectIsNull.Value)
{
//find the group of the source termset
TermGroup _targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(_targetTermGroup, group => group.Id,
group => group.Name);
targetClientContext.ExecuteQuery();
if (!_targetTermGroup.ServerObjectIsNull.Value)
{
if (!targetTermSetCheck.Group.Id.Equals(_targetTermGroup.Id))
{
//move the termset to this group
Log.Internal.TraceInformation((int)EventId.TermSet_Move, "Move termset {0} to group {1}", targetTermSetCheck.Name, _targetTermGroup.Name);
targetTermSetCheck.Move(_targetTermGroup);
targetClientContext.ExecuteQuery();
}
}
}
}
catch
{
}
}
#endregion
#region Copy termset
else if (_changeItem.Operation == ChangedOperationType.Copy)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
TermSet targetTermSetCheck = targetTermStore.GetTermSet(sourceTermset.Id);
targetClientContext.Load(targetTermSetCheck);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermSetCheck.ServerObjectIsNull.Value)
{
Log.Internal.TraceInformation((int)EventId.TermSet_AlreadyExists, "Termset: {0} already exists", sourceTermset.Name);
continue;
}
}
catch
{
}
Log.Internal.TraceInformation((int)EventId.TermSet_Copy, "Copying termset: {0}", sourceTermset.Name);
TermSet targetTermSet = targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
//Refresh session and termstore references to force reload of the termset just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created termset cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(targetTermSet, termset => termset.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTermSet(sourceClientContext, targetClientContext, sourceTermset, targetTermSet);
// reuse first level of children with the recursive flag set to true
foreach (Term child in sourceTermset.Terms)
{
Term targetChild = targetTermStore.GetTerm(child.Id);
targetClientContext.Load(targetChild);
targetClientContext.ExecuteQuery();
if (!targetChild.ServerObjectIsNull.Value)
{
targetTermSet.ReuseTerm(targetChild, true);
}
}
targetClientContext.ExecuteQuery();
}
#endregion
#region Add termset
else if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
//Group may exist with another name
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermset.Group.Name);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
TermSet targetTermSetCheck = targetTermGroup.TermSets.GetByName(sourceTermset.Name);
targetClientContext.Load(targetTermSetCheck);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermSetCheck.ServerObjectIsNull.Value)
{
Log.Internal.TraceInformation((int)EventId.TermSet_AlreadyExists, "Termset: {0} already exists", sourceTermset.Name);
continue;
}
}
catch
{
}
Log.Internal.TraceInformation((int)EventId.TermSet_Add, "Adding termset: {0}", sourceTermset.Name);
TermSet _targetTermSet = targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
//Refresh session and termstore references to force reload of the term just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created termset cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(_targetTermSet, termset => termset.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTermSet(sourceClientContext, targetClientContext, sourceTermset, _targetTermSet);
}
#endregion
#region Edit termset
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = null;
TermSet targetTermSet = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name,
termset => termset.CustomProperties);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (!targetTermGroup.ServerObjectIsNull.Value)
{
targetTermSet = targetTermGroup.TermSets.GetByName(sourceTermset.Name);
targetClientContext.Load(targetTermSet, termset => termset.Name,
termset => termset.CustomProperties);
targetClientContext.ExecuteQuery();
}
}
if (!targetTermSet.ServerObjectIsNull.Value)
{
Log.Internal.TraceInformation((int)EventId.TermSet_Edit, "Modifying termset: {0}", sourceTermset.Name);
UpdateTermSet(sourceClientContext, targetClientContext, sourceTermset, targetTermSet);
}
else
{
Log.Internal.TraceInformation((int)EventId.TermSet_NotFoundCreating, "Termset: {0} not found, creating it", sourceTermset.Name);
TermSet _targetTermSet = targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
//Refresh session and termstore references to force reload of the termset just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created termset cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(targetTermSet, termset => termset.Name,
termset => termset.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTermSet(sourceClientContext, targetClientContext, sourceTermset, _targetTermSet);
}
}
#endregion
}
}
#endregion
#region Term changes
if (_changeItem.ItemType == ChangedItemType.Term)
{
#region Delete term
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
//Check if the termset is in the group we're processing. If the termset inclusion list is not set then this will just return true
if (IsTermInIncludedTermSets(targetClientContext, targetTerm, termSetInclusions))
{
if (IsTermInExcludedGroup(targetClientContext, targetTerm, termGroupExclusions))
{
Log.Internal.TraceInformation((int)EventId.Term_Skip, "Skip term {0} due to included in excluded group", targetTerm.Name);
continue;
}
}
else
{
Log.Internal.TraceInformation((int)EventId.Term_Skip_Inclusion, "Skip term {0} due to not included in termset inclusion group", targetTerm.Name);
continue;
}
Log.Internal.TraceInformation((int)EventId.Term_Delete, "Deleting term: {0}", targetTerm.Name);
targetTerm.DeleteObject();
targetClientContext.ExecuteQuery();
}
}
#endregion
else
{
Term sourceTerm = sourceTermStore.GetTerm(_changeItem.Id);
sourceClientContext.Load(sourceTerm, term => term.Name,
term => term.Description,
term => term.Id,
term => term.Parent,
term => term.IsAvailableForTagging,
term => term.IsDeprecated,
term => term.LocalCustomProperties,
term => term.CustomProperties,
term => term.Labels.Include(label => label.Value, label => label.Language, label => label.IsDefaultForLanguage),
term => term.TermSet, termset => termset.Id);
sourceClientContext.ExecuteQuery();
if (!sourceTerm.ServerObjectIsNull.Value)
{
//Check if the termset is in the group we're processing. If the termset inclusion list is not set then this will just return true
if (IsTermInIncludedTermSets(sourceClientContext, sourceTerm, termSetInclusions))
{
//Check if the termset is not in a group we're not processing
if (IsTermInExcludedGroup(sourceClientContext, sourceTerm, termGroupExclusions))
{
Log.Internal.TraceInformation((int)EventId.Term_Skip, "Skip term {0} due to included in excluded group", sourceTerm.Name);
continue;
}
}
else
{
Log.Internal.TraceInformation((int)EventId.Term_Skip_Inclusion, "Skip term {0} due to not included in termset inclusion group", sourceTerm.Name);
continue;
}
TermSet sourceTermSet = sourceTermStore.GetTermSet(sourceTerm.TermSet.Id);
sourceClientContext.Load(sourceTermSet, termset => termset.Name,
termset => termset.Id,
termset => termset.Group);
sourceClientContext.ExecuteQuery();
TermSet targetTermSet = targetTermStore.GetTermSet(sourceTerm.TermSet.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
noError = false;
break;
}
#region Move term
else if (_changeItem.Operation == ChangedOperationType.Move)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
TermSetItem newParent = null;
if (!sourceTerm.Parent.ServerObjectIsNull.Value)
{
// Source was moved to another term
sourceClientContext.Load(sourceTerm, term => term.Parent, parent => parent.Id);
sourceClientContext.ExecuteQuery();
newParent = targetTermStore.GetTerm(sourceTerm.Parent.Id);
}
else
{
// Source was moved the root of a termset
sourceClientContext.Load(sourceTerm, term => term.TermSet, termset => termset.Id);
sourceClientContext.ExecuteQuery();
newParent = targetTermStore.GetTermSet(sourceTerm.TermSet.Id);
}
if (newParent != null)
{
Log.Internal.TraceInformation((int)EventId.Term_Move, "Term {0} moved to parent id {1}", targetTerm.Name, sourceTerm.TermSet.Id);
targetTerm.Move(newParent);
targetClientContext.ExecuteQuery();
}
}
}
#endregion
#region Copy term
else if (_changeItem.Operation == ChangedOperationType.Copy)
{
//when a term is copied with it's children you'll see multiple copy changelog entries
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (targetTerm.ServerObjectIsNull.Value)
{
Term _targetTerm = null;
// Check if the term is a sub term
if (!sourceTerm.Parent.ServerObjectIsNull.Value)
{
sourceClientContext.Load(sourceTerm, term => term.Parent, parent => parent.Id);
sourceClientContext.ExecuteQuery();
//find the parent target term with the same ID
Term parentTargetTerm = targetTermStore.GetTerm(sourceTerm.Parent.Id);
targetClientContext.Load(parentTargetTerm);
targetClientContext.ExecuteQuery();
_targetTerm = parentTargetTerm.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
}
else
{
_targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
}
//Refresh session and termstore references to force reload of the term just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created term cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(_targetTerm, term => term.IsDeprecated,
term => term.LocalCustomProperties,
term => term.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTerm(sourceClientContext, targetClientContext, sourceTerm, _targetTerm, languagesToProcess);
targetClientContext.ExecuteQuery();
Log.Internal.TraceInformation((int)EventId.Term_Copy, "Term {0} copied", _targetTerm.Name);
}
}
#endregion
#region PathChange
else if (_changeItem.Operation == ChangedOperationType.PathChange)
{
//PathChange Term detected...can be ignored so it seems
}
#endregion
#region Merge term
else if (_changeItem.Operation == ChangedOperationType.Merge)
{
Term targetTerm = targetTermStore.GetTerm(sourceTerm.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
sourceClientContext.Load(sourceTerm, term => term.MergedTermIds);
sourceClientContext.ExecuteQuery();
foreach (Guid mergedTermId in sourceTerm.MergedTermIds)
{
Term termToMerge = targetTermStore.GetTerm(mergedTermId);
targetClientContext.Load(termToMerge, term => term.Name);
targetClientContext.ExecuteQuery();
if (!termToMerge.ServerObjectIsNull.Value)
{
if (!targetTerm.MergedTermIds.Contains<Guid>(mergedTermId))
{
termToMerge.Merge(targetTerm);
targetClientContext.ExecuteQuery();
Log.Internal.TraceInformation((int)EventId.Term_Merge, "Term {0} merged to term {1}", termToMerge.Name, targetTerm.Name);
}
}
}
}
}
#endregion
#region Add Term
else if (_changeItem.Operation == ChangedOperationType.Add)
{
Term targetTerm = targetTermStore.GetTerm(sourceTerm.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (targetTerm.ServerObjectIsNull.Value)
{
Log.Internal.TraceInformation((int)EventId.Term_Add, "Creating term: {0}", sourceTerm.Name);
Term _targetTerm = null;
// Check if the term is a sub term
if (!sourceTerm.Parent.ServerObjectIsNull.Value)
{
sourceClientContext.Load(sourceTerm, term => term.Parent, parent => parent.Id);
sourceClientContext.ExecuteQuery();
//find the parent target term with the same ID
Term parentTargetTerm = targetTermStore.GetTerm(sourceTerm.Parent.Id);
targetClientContext.Load(parentTargetTerm);
targetClientContext.ExecuteQuery();
_targetTerm = parentTargetTerm.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
}
else
{
_targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
}
//Refresh session and termstore references to force reload of the term just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created term cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(_targetTerm, term => term.IsDeprecated,
term => term.LocalCustomProperties,
term => term.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTerm(sourceClientContext, targetClientContext, sourceTerm, _targetTerm, languagesToProcess);
}
}
#endregion
#region Edit term
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm, term => term.Name,
term => term.Description,
term => term.IsAvailableForTagging,
term => term.IsDeprecated,
term => term.LocalCustomProperties,
term => term.CustomProperties,
term => term.Labels.Include(label => label.Value, label => label.Language, label => label.IsDefaultForLanguage));
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
UpdateTerm(sourceClientContext, targetClientContext, sourceTerm, targetTerm, languagesToProcess);
Log.Internal.TraceInformation((int)EventId.Term_Edit, "Term {0} updated", targetTerm.Name);
}
else
{
try
{
Term _targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
//Refresh session and termstore references to force reload of the term just added. This is
//needed cause there can be a update change event following next and without this trick
//the newly created termset cannot be obtained from the server
targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore, store => store.Name,
store => store.DefaultLanguage,
store => store.Languages,
store => store.Groups.Include(group => group.Name, group => group.Id));
targetClientContext.Load(_targetTerm, term => term.IsDeprecated,
term => term.LocalCustomProperties,
term => term.CustomProperties);
targetClientContext.ExecuteQuery();
UpdateTerm(sourceClientContext, targetClientContext, sourceTerm, _targetTerm, languagesToProcess);
Log.Internal.TraceInformation((int)EventId.Term_NotFoundCreating, "Term: {0} not found, creating it", sourceTerm.Name);
}
catch
{
}
}
}
#endregion
}
}
}
#endregion
}
if (noError)
{
targetClientContext.ExecuteQuery();
}
}
return true;
}
public async Task <ChangeInformation> GetTimeTableChanges()
{
var result = new ChangeInformation();
var changes = new List <ChangeInformationItem>();
var client = new HttpClient();
var res = await client.GetStringAsync("http://www.manos-dresden.de/aktuelles/vplan.php");
var parser = new HtmlParser();
var doc = parser.Parse(res);
var cell = doc.All.Where(m => m.ClassList.Contains("s6")).First();
var table = cell.Parent.Parent;
var rows = table.ChildNodes.Where(e => e is IHtmlTableRowElement).Cast <IHtmlTableRowElement>();
//htmlDoc.LoadHtml(res);
//var table = htmlDoc.DocumentNode.SelectNodes(@"//td[@class='s6']/../../tbody");
DateTime date = DateTime.Now;
var dateSpecified = false;
foreach (var row in rows)
{
if (row.Cells[0].TextContent.Contains("Vertretungsplan"))
{
//DateTime.TryParse(row.Cells[2].TextContent,out date);
var culture = new CultureInfo("de-DE");
var styles = DateTimeStyles.None;
var index = row.Cells[2].TextContent.IndexOf("(");
var dateString = row.Cells[2].TextContent.Substring(0, index);
dateSpecified = DateTime.TryParse(dateString, culture, styles, out date);
}
if (row.Cells.Count() != 6 || (!row.Cells.FirstOrDefault()?.ClassList.Contains("s9") ?? true))
{
continue;
}
var data = new ChangeInformationItem();
data.ClassString = row.Cells[0].TextContent;
data.HourNumber = int.Parse(row.Cells[1].TextContent);
data.Subject = row.Cells[2].TextContent;
data.Teacher = row.Cells[3].TextContent;
data.Room = row.Cells[4].TextContent;
data.Description = row.Cells[5].TextContent;
if (data.ClassString?.Contains(",") ?? false)
{
var classStrings = data.ClassString.Split(',');
foreach (var classSting in classStrings)
{
var tempData = data.Clone();
tempData.ClassString = classSting;
changes.Add(tempData);
}
continue;
}
changes.Add(data);
}
result.Date = date;
result.Changes = changes;
return(result);
}
public void ProcessChanges(ClientContext sourceClientContext, ClientContext targetClientContext, List <string> termSetNames)
{
List <TermOperation> _list = new List <TermOperation>();
DateTime _startFrom = DateTime.Now.AddYears(-1);
Console.WriteLine("Opening the taxonomy session");
TaxonomySession _sourceTaxonomySession = TaxonomySession.GetTaxonomySession(sourceClientContext);
TermStore sourceTermStore = _sourceTaxonomySession.GetDefaultKeywordsTermStore();
sourceClientContext.Load(sourceTermStore);
sourceClientContext.ExecuteQuery();
Console.WriteLine("Reading the changes");
ChangeInformation _ci = new ChangeInformation(sourceClientContext);
_ci.StartTime = _startFrom;
ChangedItemCollection _cic = sourceTermStore.GetChanges(_ci);
sourceClientContext.Load(_cic);
sourceClientContext.ExecuteQuery();
if (_cic.Count > 0)
{
bool noError = true;
// Load up the taxonomy item names.
TaxonomySession targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
TermStore targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore,
store => store.Name,
store => store.DefaultLanguage,
store => store.Groups.Include(
group => group.Name, group => group.Id));
targetClientContext.ExecuteQuery();
foreach (ChangedItem _changeItem in _cic)
{
Guid g = _changeItem.Id;
if (_changeItem.ItemType == ChangedItemType.Group)
{
TermGroup sourceTermGroup = sourceTermStore.GetGroup(_changeItem.Id);
sourceClientContext.Load(sourceTermGroup, group => group.Name, group => group.Id, group => group.IsSystemGroup, group => group.Description);
sourceClientContext.ExecuteQuery();
if (sourceTermGroup.ServerObjectIsNull.Value)
{
continue;
}
else
{
if (sourceTermGroup.IsSystemGroup)
{
Console.WriteLine("Group \"" + sourceTermGroup.Name + "\" is a system group");
continue;
}
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
foreach (TermSet ts in targetTermGroup.TermSets)
{
Console.WriteLine("Deleting termset: " + ts.Name);
TermOperation op = new TermOperation();
op.Term = ts.Name;
op.Id = ts.Id.ToString();
op.Operation = "Delete";
op.Type = "TermSet";
_list.Add(op);
ts.DeleteObject();
}
Console.WriteLine("Deleting group: " + sourceTermGroup.Name);
targetTermGroup.DeleteObject();
TermOperation op2 = new TermOperation();
op2.Term = sourceTermGroup.Name;
op2.Id = _changeItem.Id.ToString();
op2.Operation = "Delete";
op2.Type = "TermGroup";
_list.Add(op2);
targetClientContext.ExecuteQuery();
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup, group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
TermGroup targetTermGroupTest = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroupTest, group => group.Name);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermGroupTest.ServerObjectIsNull.Value)
{
if (sourceTermGroup.Name.ToLower() == "system" || sourceTermGroup.Name.ToLower() == "people")
{
Console.WriteLine("Group: " + sourceTermGroup.Name + " already exists");
continue;
}
else
{
InvalidOperationException uEx = new InvalidOperationException("A group named: \"" + sourceTermGroup.Name + "\" already exists but with a different ID. Please delete the term group from the target termstore");
break;
}
}
}
catch
{
}
Console.WriteLine("Adding group: " + sourceTermGroup.Name);
TermGroup _targetTermGroup = targetTermStore.CreateGroup(sourceTermGroup.Name, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTermGroup.Description))
{
_targetTermGroup.Description = sourceTermGroup.Description;
}
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
targetTermStore.RefreshLoad();
TermOperation op = new TermOperation();
op.Term = sourceTermGroup.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermGroup";
_list.Add(op);
}
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
if (targetTermGroup.Name != sourceTermGroup.Name)
{
Console.WriteLine("Modifying group: " + sourceTermGroup.Name);
targetTermGroup.Name = sourceTermGroup.Name;
TermOperation op = new TermOperation();
op.Term = sourceTermGroup.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "TermGroup";
_list.Add(op);
targetClientContext.ExecuteQuery();
}
}
}
if (_changeItem.ItemType == ChangedItemType.TermSet)
{
TermSet sourceTermset = sourceTermStore.GetTermSet(_changeItem.Id);
sourceClientContext.Load(sourceTermset, termset => termset.Name,
termset => termset.Id,
termset => termset.Description,
termset => termset.Contact,
termset => termset.CustomProperties,
termset => termset.Group, group => group.Id);
sourceClientContext.ExecuteQuery();
if (sourceTermset.ServerObjectIsNull.Value)
{
continue;
}
if (!termSetNames.Contains(sourceTermset.Name))
{
continue;
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermSet targetTermset = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermset);
targetClientContext.ExecuteQuery();
Console.WriteLine("Deleting termset: " + targetTermset.Name);
targetTermset.DeleteObject();
targetClientContext.ExecuteQuery();
TermOperation op = new TermOperation();
op.Term = targetTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Delete";
op.Type = "TermSet";
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.IsSystemGroup,
group => group.TermSets.Include(
termSet => termSet.Name, termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
//Group may exist with another name
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermset.Group.Name);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.IsSystemGroup,
group => group.TermSets.Include(
termSet => termSet.Name, termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
TermSet targetTermSetCheck = targetTermGroup.TermSets.GetByName(sourceTermset.Name);
targetClientContext.Load(targetTermSetCheck);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermSetCheck.ServerObjectIsNull.Value)
{
Console.WriteLine("Termset: " + sourceTermset.Name + " already exists");
continue;
}
}
catch
{
}
Console.WriteLine("Adding termset: " + sourceTermset.Name);
targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
TermOperation op = new TermOperation();
op.Term = sourceTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermSet";
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
targetTermStore.RefreshLoad();
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = null;
TermSet sourceTermSet = sourceTermStore.GetTermSet(_changeItem.Id);
sourceClientContext.Load(sourceTermSet, termset => termset.Name);
sourceClientContext.ExecuteQuery();
TermSet targetTermSet = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup, group => group.Name, group => group.IsSystemGroup);
targetClientContext.ExecuteQuery();
if (!targetTermGroup.ServerObjectIsNull.Value)
{
targetTermSet = targetTermGroup.TermSets.GetByName(sourceTermSet.Name);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
}
}
if (!targetTermSet.ServerObjectIsNull.Value)
{
if (targetTermSet.Name != sourceTermSet.Name)
{
Console.WriteLine("Modifying termset: " + sourceTermSet.Name);
targetTermSet.Name = sourceTermSet.Name;
TermOperation op = new TermOperation();
op.Term = sourceTermSet.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "TermSet";
_list.Add(op);
}
}
else
{
Console.WriteLine("Termset: " + sourceTermset.Name + " not found, creating it");
targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
TermOperation op = new TermOperation();
op.Term = sourceTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermSet";
_list.Add(op);
}
}
}
if (_changeItem.ItemType == ChangedItemType.Term)
{
Term sourceTerm = sourceTermStore.GetTerm(_changeItem.Id);
sourceClientContext.Load(sourceTerm,
term => term.Name,
term => term.Description,
term => term.Id,
term => term.TermSet,
termset => termset.Id);
sourceClientContext.ExecuteQuery();
if (!sourceTerm.ServerObjectIsNull.Value)
{
TermSet sourceTermSet = sourceTermStore.GetTermSet(sourceTerm.TermSet.Id);
sourceClientContext.Load(sourceTermSet,
termset => termset.Name,
termset => termset.Id,
termset => termset.Group);
sourceClientContext.ExecuteQuery();
if (!sourceTermSet.ServerObjectIsNull.Value)
{
if (!termSetNames.Contains(sourceTermSet.Name))
{
continue;
}
}
TermSet targetTermSet = targetTermStore.GetTermSet(sourceTerm.TermSet.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
noError = false;
break;
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
Console.WriteLine("Deleting term: " + sourceTerm.Name);
targetTerm.DeleteObject();
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Delete";
op.Type = "Term";
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
Term targetTerm = targetTermStore.GetTerm(sourceTerm.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (targetTerm.ServerObjectIsNull.Value)
{
Console.WriteLine("Creating term: " + sourceTerm.Name);
Term _targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTerm.Description))
{
_targetTerm.SetDescription(sourceTerm.Description, targetTermStore.DefaultLanguage);
}
//GetLabels from Source
targetClientContext.ExecuteQuery();
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "Term";
_list.Add(op);
}
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm, term => term.Name);
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
if (targetTerm.Name != sourceTerm.Name)
{
targetTerm.Name = sourceTerm.Name;
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "Term";
_list.Add(op);
}
}
else
{
try
{
Term _targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTerm.Description))
{
_targetTerm.SetDescription(sourceTerm.Description, targetTermStore.DefaultLanguage);
}
targetClientContext.ExecuteQuery();
Console.WriteLine("Term: " + sourceTerm.Name + " not found, creating it");
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "Term";
_list.Add(op);
}
catch
{
}
}
}
}
}
}
if (noError)
{
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
}
}
}
public void ProcessChanges(ClientContext sourceClientContext, ClientContext targetClientContext , List<string> termSetNames)
{
List<TermOperation> _list = new List<TermOperation>();
DateTime _startFrom = DateTime.Now.AddYears(-1);
Console.WriteLine("Opening the taxonomy session");
TaxonomySession _sourceTaxonomySession = TaxonomySession.GetTaxonomySession(sourceClientContext);
TermStore sourceTermStore = _sourceTaxonomySession.GetDefaultKeywordsTermStore();
sourceClientContext.Load(sourceTermStore);
sourceClientContext.ExecuteQuery();
Console.WriteLine("Reading the changes");
ChangeInformation _ci = new ChangeInformation(sourceClientContext);
_ci.StartTime = _startFrom;
ChangedItemCollection _cic = sourceTermStore.GetChanges(_ci);
sourceClientContext.Load(_cic);
sourceClientContext.ExecuteQuery();
if (_cic.Count > 0)
{
bool noError = true;
// Load up the taxonomy item names.
TaxonomySession targetTaxonomySession = TaxonomySession.GetTaxonomySession(targetClientContext);
TermStore targetTermStore = targetTaxonomySession.GetDefaultKeywordsTermStore();
targetClientContext.Load(targetTermStore,
store => store.Name,
store => store.DefaultLanguage,
store => store.Groups.Include(
group => group.Name, group => group.Id));
targetClientContext.ExecuteQuery();
foreach (ChangedItem _changeItem in _cic)
{
Guid g = _changeItem.Id;
if (_changeItem.ItemType == ChangedItemType.Group)
{
TermGroup sourceTermGroup = sourceTermStore.GetGroup(_changeItem.Id);
sourceClientContext.Load(sourceTermGroup, group => group.Name, group => group.Id, group => group.IsSystemGroup, group => group.Description);
sourceClientContext.ExecuteQuery();
if (sourceTermGroup.ServerObjectIsNull.Value)
{
continue;
}
else
{
if (sourceTermGroup.IsSystemGroup)
{
Console.WriteLine("Group \"" + sourceTermGroup.Name + "\" is a system group");
continue;
}
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
foreach (TermSet ts in targetTermGroup.TermSets)
{
Console.WriteLine("Deleting termset: " + ts.Name);
TermOperation op = new TermOperation();
op.Term = ts.Name;
op.Id = ts.Id.ToString();
op.Operation = "Delete";
op.Type = "TermSet";
_list.Add(op);
ts.DeleteObject();
}
Console.WriteLine("Deleting group: " + sourceTermGroup.Name);
targetTermGroup.DeleteObject();
TermOperation op2 = new TermOperation();
op2.Term = sourceTermGroup.Name;
op2.Id = _changeItem.Id.ToString();
op2.Operation = "Delete";
op2.Type = "TermGroup";
_list.Add(op2);
targetClientContext.ExecuteQuery();
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup, group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
TermGroup targetTermGroupTest = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroupTest, group => group.Name);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermGroupTest.ServerObjectIsNull.Value)
{
if (sourceTermGroup.Name.ToLower() == "system" || sourceTermGroup.Name.ToLower() == "people")
{
Console.WriteLine("Group: " + sourceTermGroup.Name + " already exists");
continue;
}
else
{
InvalidOperationException uEx = new InvalidOperationException("A group named: \"" + sourceTermGroup.Name + "\" already exists but with a different ID. Please delete the term group from the target termstore");
break;
}
}
}
catch
{
}
Console.WriteLine("Adding group: " + sourceTermGroup.Name);
TermGroup _targetTermGroup = targetTermStore.CreateGroup(sourceTermGroup.Name, _changeItem.Id);
if(!string.IsNullOrEmpty(sourceTermGroup.Description))
{
_targetTermGroup.Description = sourceTermGroup.Description;
}
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
targetTermStore.RefreshLoad();
TermOperation op = new TermOperation();
op.Term = sourceTermGroup.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermGroup";
_list.Add(op);
}
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(_changeItem.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.Id,
group => group.TermSets.Include(
termSet => termSet.Name,
termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermGroup.Name);
targetClientContext.Load(targetTermGroup, group => group.Name);
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
if (targetTermGroup.Name != sourceTermGroup.Name)
{
Console.WriteLine("Modifying group: " + sourceTermGroup.Name);
targetTermGroup.Name = sourceTermGroup.Name;
TermOperation op = new TermOperation();
op.Term = sourceTermGroup.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "TermGroup";
_list.Add(op);
targetClientContext.ExecuteQuery();
}
}
}
if (_changeItem.ItemType == ChangedItemType.TermSet)
{
TermSet sourceTermset = sourceTermStore.GetTermSet(_changeItem.Id);
sourceClientContext.Load(sourceTermset, termset => termset.Name,
termset => termset.Id,
termset => termset.Description,
termset => termset.Contact,
termset => termset.CustomProperties,
termset => termset.Group, group => group.Id);
sourceClientContext.ExecuteQuery();
if (sourceTermset.ServerObjectIsNull.Value)
{
continue;
}
if (!termSetNames.Contains(sourceTermset.Name))
{
continue;
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
TermSet targetTermset = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermset);
targetClientContext.ExecuteQuery();
Console.WriteLine("Deleting termset: " + targetTermset.Name);
targetTermset.DeleteObject();
targetClientContext.ExecuteQuery();
TermOperation op = new TermOperation();
op.Term = targetTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Delete";
op.Type = "TermSet";
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
TermGroup targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.IsSystemGroup,
group => group.TermSets.Include(
termSet => termSet.Name, termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
//Group may exist with another name
targetTermGroup = targetTermStore.Groups.GetByName(sourceTermset.Group.Name);
targetClientContext.Load(targetTermGroup,
group => group.Name,
group => group.IsSystemGroup,
group => group.TermSets.Include(
termSet => termSet.Name, termSet => termSet.Id));
targetClientContext.ExecuteQuery();
if (targetTermGroup.ServerObjectIsNull.Value)
{
noError = false;
break;
}
}
TermSet targetTermSetCheck = targetTermGroup.TermSets.GetByName(sourceTermset.Name);
targetClientContext.Load(targetTermSetCheck);
try
{
targetClientContext.ExecuteQuery();
if (!targetTermSetCheck.ServerObjectIsNull.Value)
{
Console.WriteLine("Termset: " + sourceTermset.Name + " already exists");
continue;
}
}
catch
{
}
Console.WriteLine("Adding termset: " + sourceTermset.Name);
targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
TermOperation op = new TermOperation();
op.Term = sourceTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermSet";
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
targetTermStore.RefreshLoad();
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
TermGroup targetTermGroup = null;
TermSet sourceTermSet = sourceTermStore.GetTermSet(_changeItem.Id);
sourceClientContext.Load(sourceTermSet, termset => termset.Name);
sourceClientContext.ExecuteQuery();
TermSet targetTermSet = targetTermStore.GetTermSet(_changeItem.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
targetTermGroup = targetTermStore.GetGroup(sourceTermset.Group.Id);
targetClientContext.Load(targetTermGroup, group => group.Name, group => group.IsSystemGroup);
targetClientContext.ExecuteQuery();
if (!targetTermGroup.ServerObjectIsNull.Value)
{
targetTermSet = targetTermGroup.TermSets.GetByName(sourceTermSet.Name);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
}
}
if (!targetTermSet.ServerObjectIsNull.Value)
{
if (targetTermSet.Name != sourceTermSet.Name)
{
Console.WriteLine("Modifying termset: " + sourceTermSet.Name);
targetTermSet.Name = sourceTermSet.Name;
TermOperation op = new TermOperation();
op.Term = sourceTermSet.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "TermSet";
_list.Add(op);
}
}
else
{
Console.WriteLine("Termset: " + sourceTermset.Name + " not found, creating it");
targetTermGroup.CreateTermSet(sourceTermset.Name, _changeItem.Id, targetTermStore.DefaultLanguage);
TermOperation op = new TermOperation();
op.Term = sourceTermset.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "TermSet";
_list.Add(op);
}
}
}
if (_changeItem.ItemType == ChangedItemType.Term)
{
Term sourceTerm = sourceTermStore.GetTerm(_changeItem.Id);
sourceClientContext.Load(sourceTerm,
term => term.Name,
term => term.Description,
term => term.Id,
term => term.TermSet,
termset => termset.Id);
sourceClientContext.ExecuteQuery();
if (!sourceTerm.ServerObjectIsNull.Value)
{
TermSet sourceTermSet = sourceTermStore.GetTermSet(sourceTerm.TermSet.Id);
sourceClientContext.Load(sourceTermSet,
termset => termset.Name,
termset => termset.Id,
termset => termset.Group);
sourceClientContext.ExecuteQuery();
if (!sourceTermSet.ServerObjectIsNull.Value)
{
if(!termSetNames.Contains(sourceTermSet.Name))
{
continue;
}
}
TermSet targetTermSet = targetTermStore.GetTermSet(sourceTerm.TermSet.Id);
targetClientContext.Load(targetTermSet, termset => termset.Name);
targetClientContext.ExecuteQuery();
if (targetTermSet.ServerObjectIsNull.Value)
{
noError = false;
break;
}
if (_changeItem.Operation == ChangedOperationType.DeleteObject)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
Console.WriteLine("Deleting term: " + sourceTerm.Name);
targetTerm.DeleteObject();
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Delete";
op.Type = "Term";
_list.Add(op);
}
else if (_changeItem.Operation == ChangedOperationType.Add)
{
Term targetTerm = targetTermStore.GetTerm(sourceTerm.Id);
targetClientContext.Load(targetTerm);
targetClientContext.ExecuteQuery();
if (targetTerm.ServerObjectIsNull.Value)
{
Console.WriteLine("Creating term: " + sourceTerm.Name);
Term _targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTerm.Description))
{
_targetTerm.SetDescription(sourceTerm.Description, targetTermStore.DefaultLanguage);
}
//GetLabels from Source
targetClientContext.ExecuteQuery();
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "Term";
_list.Add(op);
}
}
else if (_changeItem.Operation == ChangedOperationType.Edit)
{
Term targetTerm = targetTermStore.GetTerm(_changeItem.Id);
targetClientContext.Load(targetTerm, term => term.Name);
targetClientContext.ExecuteQuery();
if (!targetTerm.ServerObjectIsNull.Value)
{
if (targetTerm.Name != sourceTerm.Name)
{
targetTerm.Name = sourceTerm.Name;
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Modify";
op.Type = "Term";
_list.Add(op);
}
}
else
{
try
{
Term _targetTerm = targetTermSet.CreateTerm(sourceTerm.Name, targetTermStore.DefaultLanguage, _changeItem.Id);
if (!string.IsNullOrEmpty(sourceTerm.Description))
{
_targetTerm.SetDescription(sourceTerm.Description, targetTermStore.DefaultLanguage);
}
targetClientContext.ExecuteQuery();
Console.WriteLine("Term: " + sourceTerm.Name + " not found, creating it");
TermOperation op = new TermOperation();
op.Term = sourceTerm.Name;
op.Id = _changeItem.Id.ToString();
op.Operation = "Add";
op.Type = "Term";
_list.Add(op);
}
catch
{
}
}
}
}
}
}
if (noError)
{
targetClientContext.ExecuteQuery();
targetTermStore.CommitAll();
}
}
}
