public void SaveToolkitCachesToolkitAndUser()
{
//Arrange
_spClientMock.Setup(r => r.GetUserIdFromToolkit(It.IsAny <ToolkitUser>(), It.IsAny <Toolkit>())).Returns(1);
var toolkits = new List <Toolkit>()
{
new Toolkit()
{
CustomerName = "AKA",
Url = "Test",
UserId = 1
},
};
var user = new ToolkitUser()
{
Name = "Morten",
Password = "******",
};
//Act
_timeManager.SyncToolkits(user, toolkits);
//Assert
var privateObj = new PrivateObject(_timeManager);
var privInfo = privateObj.GetField("_toolkitInfo");
var privUser = privateObj.GetField("_toolkitUser");
Assert.AreEqual(toolkits, privInfo);
Assert.AreEqual(user, privUser);
}
public virtual void SyncToolkits(ToolkitUser toolkitUser, List <Toolkit> toolkits)
{
//Get user ids
//foreach (var tk in toolkits)
for (var i = 0; i < toolkits.Count; i++)
{
var tk = toolkits[i];
tk.CustomerName = GetCustomerNameFromUrl(tk);
if (tk.UserId == 0)
{
tk.UserId = _sharepointClient.GetUserIdFromToolkit(toolkitUser, tk);
}
if (_toolkits.IsNullOrEmpty() || ToolkitInfoChanged(tk, _toolkits))
{
tk.Teams = _sharepointClient.GetTeamsFromToolkit(toolkitUser, tk);
tk = _sharepointClient.GetTimeslotInformationFromToolkit(toolkitUser, tk);
}
toolkits[i] = tk;
}
//call repo to save
_toolkitRepository.SaveData(toolkits);
_toolkits = toolkits;
_toolkitUser = toolkitUser;
}
/// <summary>
/// Call Sharepoint and do clean up for stored timeregs
/// </summary>
public virtual void SyncTimeregs(List <Timeregistration> timeregs)
{
//TODO: Add logging + give user feedback when timeregs are synchronised.
_toolkitUser = _toolkitUser ?? _toolkitUserRepository.GetData();
_toolkits = _toolkits ?? _toolkitRepository.GetData();
var distinctTkDisplayNames = timeregs.Select(x => x.ToolkitDisplayName).Distinct();
foreach (var tkDisplayName in distinctTkDisplayNames)
{
var timeregsInTk = timeregs.Where(x => x.ToolkitDisplayName == tkDisplayName).ToList();
var tk = _toolkits.Single(x => x.DisplayName == tkDisplayName);
_sharepointClient.MakeTimeregistrations(timeregsInTk, _toolkitUser, tk);
}
//Send to Sharepoint
foreach (var timereg in timeregs.Where(tr => !tr.IsSynchronized))
{
var toolkit = GetRelevantToolkit(timereg);
var id = _sharepointClient.MakeTimeregistration(timereg, _toolkitUser, toolkit);
timereg.IsSynchronized = id != -1;
}
_timeregistrationRepository.SaveData(timeregs);
}
public virtual List <Team> GetTeamsFromToolkit(ToolkitUser tkUser, Toolkit tk)
{
var clientContext = new ClientContext(tk.Url)
{
Credentials = new NetworkCredential(tkUser.Name, tkUser.SecurePassword, tkUser.Domain)
};
return(tk.GetTeamsWithoutSLA ? GetAllTeams(clientContext) : GetTeamsWithActiveSLA(clientContext));
}
public virtual int MakeTimeregistration(Timeregistration timereg, ToolkitUser toolkitUser, Toolkit toolkit)
{
var clientContext = new ClientContext(toolkit.Url)
{
Credentials = new NetworkCredential(toolkitUser.Name, toolkitUser.SecurePassword, toolkitUser.Domain)
};
const string timeregList = "tidsregistrering";
var sharepointList = clientContext.Web.Lists.GetByTitle(timeregList);
clientContext.Load(sharepointList);
clientContext.ExecuteQuery();
var itemCreateInfo = new ListItemCreationInformation();
var sharepointListItem = sharepointList.AddItem(itemCreateInfo);
var success = timereg.CouldConvertDurationToHours();
if (!success)
{
return(-1);
}
var doneBy = new SPFieldLookupValue(toolkit.UserId, toolkitUser.Name);
var author = new SPFieldLookupValue(toolkit.UserId, toolkitUser.Name);
if (timereg.IsWorkPackage)
{
sharepointListItem["Case"] = FindRelatedCaseForWorkPackage(clientContext, timereg.CaseId);
var toolkitWorkPackage = new SPFieldLookupValue(timereg.CaseId, "");
sharepointListItem["WorkPackage"] = toolkitWorkPackage;
}
else
{
var toolkitCase = new SPFieldLookupValue(timereg.CaseId, $"{toolkit.CustomerName}-{timereg.CaseId}");
sharepointListItem["Case"] = toolkitCase;
}
//sharepointListItem["Hours"] = timereg.Hours;
sharepointListItem["Hours"] = timereg.Hours;
sharepointListItem["DoneBy"] = doneBy;
sharepointListItem["Author"] = author;
sharepointListItem["DoneDate"] = timereg.DoneDate;
try
{
sharepointListItem.Update();
clientContext.ExecuteQuery();
return(sharepointListItem.Id);
}
catch
{
return(-1);
}
}
public void SaveUserInfoToRepoTest()
{
_repo = new Repository <ToolkitUser>();
var userInfo = new ToolkitUser
{
Name = "MOMA",
Password = @"blablabla"
};
var success = _repo.SaveData(userInfo);
Assert.IsTrue(success);
}
public virtual int GetUserIdFromToolkit(ToolkitUser toolkitUser, Toolkit toolkit)
{
var clientContext = new ClientContext(toolkit.Url);
var userCollection = clientContext.Web.SiteUsers;
clientContext.Load(userCollection);
clientContext.ExecuteQuery();
var email = $"{toolkitUser.Name}@netcompany.com";
var user = userCollection.GetByEmail(email);
clientContext.Load(user);
clientContext.ExecuteQuery();
return(user.Id);
}
public void SaveAndGetUserInfoToRepoTest()
{
_repo = new Repository <ToolkitUser>();
var userInfo = new ToolkitUser
{
Name = "Testname",
Password = @"o_v2\J;CRpiR/mx:hx1/3d=PveE&LijSr,+k@PXL'UTH)"
};
var success = _repo.SaveData(userInfo);
var retrievedUser = _repo.GetData();
Assert.IsTrue(success);
Assert.AreEqual(userInfo.Name, retrievedUser.Name);
Assert.AreEqual(userInfo.Password, retrievedUser.Password);
}
public TimeManager(IRepository <ToolkitUser> tkUserRepo, IRepository <List <Toolkit> > tkRepo,
IRepository <List <Timeregistration> > timeregRepo, ISharepointClient spClient, IEncryption encryptionManager)
{
_toolkitUserRepository = tkUserRepo;
_toolkitRepository = tkRepo;
_timeregistrationRepository = timeregRepo;
_sharepointClient = spClient;
UserInfo = _toolkitUserRepository.GetData();
if (UserInfo.Password?.Length > 0)
{
UserInfo.SecurePassword = new NetworkCredential("", encryptionManager.DecryptText(UserInfo.Password))
.SecurePassword;
}
_toolkits = _toolkitRepository.GetData();
}
public virtual Toolkit GetTimeslotInformationFromToolkit(ToolkitUser tkUser, Toolkit tk)
{
var clientContext = new ClientContext(tk.Url)
{
Credentials = new NetworkCredential(tkUser.Name, tkUser.SecurePassword, tkUser.Domain)
};
const string list = "tidsregistrering";
var oList = clientContext.Web.Lists.GetByTitle(list);
clientContext.Load(oList);
clientContext.ExecuteQuery();
var usesTimeslots = CheckIfToolkitUsesTimeslots(clientContext, oList, tk);
if (!usesTimeslots)
{
return(tk);
}
var timeregsWithTimeslot = GetTopTimeregsWithTimeslot(clientContext, oList, tk);
var casesForTimeregsWithTimeslot =
GetCasesForTimeregsWithTimeslot(clientContext, timeregsWithTimeslot);
var teamsUsingTimeslots = casesForTimeregsWithTimeslot.GroupBy(tkCase => tkCase.Team)
.Select(tkCase => tkCase.First()).OrderBy(tkCase => tkCase.Team).ToList();
foreach (var tkCase in teamsUsingTimeslots)
{
foreach (var team in tk.Teams)
{
if (team.Name == tkCase.Team)
{
team.UsesTimeslots = true;
}
}
}
tk.Timeslots = tk.TimeslotFieldName == "TimeSlot" ? ExtractTimeslotsFromTimeslotList(clientContext) : ExtractTimeslotsFromTimeregList(clientContext, tk);
return(tk);
}
public void Init()
{
_toolkitUserRepository = new Repository <ToolkitUser>();
_toolkitUser = _toolkitUserRepository.GetData();
try
{
_toolkitUser.SecurePassword =
new NetworkCredential("", _encryptionManager.DecryptText(_toolkitUser.Password)).SecurePassword;
}
catch (Exception)
{
_toolkitUser.SecurePassword = new NetworkCredential("", "").SecurePassword;
}
_toolkitUser.Password = "";
_sharepointClient = new SharepointClient();
_clientContext = new ClientContext("https://goto.netcompany.com/cases/GTO22/NCMOD")
{
Credentials = new NetworkCredential(_toolkitUser.Name, _toolkitUser.SecurePassword, _toolkitUser.Domain)
};
}
//TODO: Add support for multiple timeregs per day for a case (i.e. group them by case id)
//Do some loop over list where we create Microsoft.SharePoint.Client.ListItem and put into SP.List oList -- SEE UNIT TEST PROJECT
//Send to Toolkit -- SEE UNIT TEST PROJECT
public virtual void MakeTimeregistrations(IEnumerable <Timeregistration> timeregs, ToolkitUser toolkitUser, Toolkit toolkit)
{
var clientContext = new ClientContext(toolkit.Url)
{
Credentials = new NetworkCredential(toolkitUser.Name, toolkitUser.SecurePassword, toolkitUser.Domain)
};
const string timeregSpListName = "tidsregistrering";
var timeregSpList = clientContext.Web.Lists.GetByTitle(timeregSpListName);
clientContext.Load(timeregSpList);
clientContext.ExecuteQuery();
var listItems = new Dictionary <CaseDateTimeslot, ListItem>();
var doneBy = new SPFieldLookupValue(toolkit.UserId, toolkitUser.Name);
var author = new SPFieldLookupValue(toolkit.UserId, toolkitUser.Name);
var itemCreateInfo = new ListItemCreationInformation();
var timeregsByCaseIdDateTimeslot = GroupTimeregistrations(timeregs);
foreach (var caseDateTimeslotGroup in timeregsByCaseIdDateTimeslot)
{
var sharepointListItem = timeregSpList.AddItem(itemCreateInfo);
var caseDateTimeslot = caseDateTimeslotGroup.Key;
var toolkitCase = new SPFieldLookupValue(caseDateTimeslot.CaseId, $"{toolkit.CustomerName}-{caseDateTimeslot.CaseId}");
var doneDate = caseDateTimeslot.Date;
var hours = CalculateDuration(caseDateTimeslotGroup.Value);
sharepointListItem["Hours"] = hours;
sharepointListItem["DoneBy"] = doneBy;
sharepointListItem["Author"] = author;
sharepointListItem["Case"] = toolkitCase;
sharepointListItem["DoneDate"] = doneDate;
sharepointListItem.Update();
listItems.Add(caseDateTimeslot, sharepointListItem);
}
try
{
clientContext.ExecuteQuery();
}
catch (Exception)
{
throw new Exception($"Unable to save timeregs to Toolkit. Toolkit: DisplayName={toolkit.DisplayName}, Url={toolkit.Url}");
}
foreach (var item in listItems)
{
var isSynchronised = item.Value.Id != -1;
foreach (var timereg in timeregsByCaseIdDateTimeslot[item.Key])
{
timereg.IsSynchronized = isSynchronised;
}
}
}
