public HttpResponseMessage UpdateBatch(IEnumerable <StagedUser> userBatch)
{
var res = HttpStatusCode.NoContent; //204, response successfully processed with no content to return
var errorMessage = "";
if (userBatch == null || userBatch.Count() == 0)
{
errorMessage = "An empty or null collection was transmitted, no users were processed.";
}
else
{
var siteDomains = SiteUtils.GetSiteDomainList(User.Identity);
try
{
StagedUserUtil.AddBulkUsersToQueue(userBatch, siteDomains);
}
catch (Exception ex)
{
res = HttpStatusCode.InternalServerError;
Logging.WriteToSyncLog("StagedUsersController/UpdateBatch", ex.Message, System.Diagnostics.EventLogEntryType.Error, ex);
errorMessage = string.Format("An error occurred processing the request, check the event log for details ({0}).", ex.Message);
}
}
HttpResponseMessage response = Request.CreateResponse(res);
response.Headers.Add("ErrorMessage", errorMessage);
return(response);
}
public async Task <IEnumerable <StagedUser> > GetAllStaged()
{
var siteDomains = SiteUtils.GetSiteDomainList(User.Identity);
var siteId = User.Identity.GetClaim(CustomClaimTypes.SiteId);
return(await StagedUserUtil.GetAllBySiteId(siteId));
}
/// <summary>
/// Get the list of users to process
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <StagedUser> > GetAllByStage(string stage)
{
LoadStageEnum loadStage = (LoadStageEnum)Enum.Parse(typeof(LoadStageEnum), stage);
var res = await StagedUserUtil.GetAllByStage(loadStage);
return(res.ToList());
}
public async Task <dynamic> SetUserStatus(SetUserObject user)
{
var stagedUser = await StagedUserUtil.GetUser(user.userId);
var response = await AdminRelayClient.SetUserStatus(user, stagedUser);
return(response);
}
public async Task <dynamic> GetUserStatus(string userId)
{
var user = await StagedUserUtil.GetUser(userId);
var response = await AdminRelayClient.GetUserStatus(user);
return(response);
}
public async Task <IEnumerable <StagedUser> > GetAllByStage(string stage)
{
LoadStageEnum loadStage = (LoadStageEnum)Enum.Parse(typeof(LoadStageEnum), stage);
var siteDomains = SiteUtils.GetSiteDomainList(User.Identity);
var siteId = User.Identity.GetClaim(CustomClaimTypes.SiteId);
return(await StagedUserUtil.GetAllByStageAndDomain(loadStage, siteDomains));
}
public async Task <Dashboard> Users()
{
var data = new Dashboard();
var users = await StagedUserUtil.GetUsers();
data.NumUsers = users.Count();
data.NumUsersPendingSync = users
.Where(u => u.LoadState.IsAnyOf(LoadStageEnum.PendingHQAdd, LoadStageEnum.PendingHQDelete, LoadStageEnum.PendingHQUpdate, LoadStageEnum.PendingRemoteUpdate))
.Count();
return(data);
}
public async Task <dynamic> ResetPw(ResetPwObject reset)
{
var userId = reset.userId;
var rst = new PasswordReset
{
NewPassword = reset.NewPassword,
SetChangePasswordAtNextLogon = reset.SetChangePasswordAtNextLogon,
Unlock = reset.Unlock,
UserName = reset.UserName
};
var stagedUser = await StagedUserUtil.GetUser(reset.userId);
var response = await AdminRelayClient.ResetPassword(rst, stagedUser);
return(response);
}
public static void ProcessUserQueue([QueueTrigger("stageduser")] string queueData, IBinder binder)
{
try
{
string data = queueData;
string containerAndBlob = "";
BlobAttribute blobAttribute;
if (Uri.IsWellFormedUriString(queueData, UriKind.Absolute))
{
var uri = new Uri(queueData);
containerAndBlob = uri.AbsolutePath.Substring(1);
blobAttribute = new BlobAttribute(containerAndBlob, FileAccess.Read);
data = queueData;
using (var stream = binder.Bind <Stream>(blobAttribute))
{
StreamReader reader = new StreamReader(stream);
data = reader.ReadToEnd();
}
}
IEnumerable <StagedUser> stagedUsers = JsonConvert.DeserializeObject <IEnumerable <StagedUser> >(data);
var res = StagedUserUtil.ProcessCollection(stagedUsers);
if (containerAndBlob.Length > 0)
{
//delete block blob
//Must be "FileAccess.ReadWrite"
blobAttribute = new BlobAttribute(containerAndBlob, FileAccess.ReadWrite);
var blockBlob = binder.Bind <CloudBlockBlob>(blobAttribute);
blockBlob.DeleteIfExists();
}
}
catch (Exception ex)
{
Logging.WriteToAppLog("Error processing queue 'stageduser'", System.Diagnostics.EventLogEntryType.Error, ex);
}
}
public async Task <IEnumerable <StagedUser> > GetUsersByDomain(string domain)
{
var res = await StagedUserUtil.GetAllByDomain(domain);
return(res.OrderBy(u => u.Surname).OrderBy(u => u.GivenName).ToList());
}
public async Task <IEnumerable <StagedUser> > GetFilteredUsersBySite(string siteId, string filter)
{
var res = await StagedUserUtil.GetFilteredBySiteId(siteId, filter);
return(res.OrderBy(u => u.Surname).OrderBy(u => u.GivenName).ToList());
}
