public async Task <Feedbacks> GetNamesForFeedback(string id)
{
var repo = new TableStorageRepository();
var feedback = await repo.GetFeedByFeedId(id);
var users = await repo.GetUsersWithoutParams();
var names = new Feedbacks {
};
foreach (var user in users)
{
if (user.Id == feedback.ID)
{
feedback.ID = user.Name;
}
if (user.Id == feedback.ID_receiver)
{
feedback.ID_receiver = user.Name;
}
if (user.Id == feedback.ID_manager)
{
feedback.ID_manager = user.Name;
}
}
return(feedback);
}
public async Task <IEnumerable <User> > GetMyTeamAsManager(string managerid)
{
var repo = new TableStorageRepository();
var users = await repo.GetUsersForTeam();
Dictionary <string, List <Models.User> > descendantsFromManager = new Dictionary <string, List <Models.User> >();
Models.User manager = new Models.User();
manager.Id = managerid;
manager.Name = managerid;
foreach (var user in users)
{
if (!descendantsFromManager.ContainsKey(user.Manager_ID))
{
descendantsFromManager[user.Manager_ID] = new List <Models.User>();
}
descendantsFromManager[user.Manager_ID].Add(user);
if (user.Name == managerid || user.Id == managerid)
{
manager = user;
}
}
Queue <Models.User> queue = new Queue <Models.User>();
List <Models.User> descendants = new List <Models.User>();
queue.Enqueue(manager);
while (queue.Count != 0)
{
var user = queue.Dequeue();
if (user.Name != managerid && user.Id != managerid)
{
descendants.Add(user);
}
if (descendantsFromManager.ContainsKey(user.Name))
{
foreach (var child in descendantsFromManager[user.Name])
{
queue.Enqueue(child);
}
descendantsFromManager.Remove(user.Name);
}
}
// descendants = descendants.Where(x => x.IsDeleted == false).ToList();
return(descendants);
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var repo = new TableStorageRepository();
await userTable.CreateIfNotExistsAsync();
var results = (await userTable.ExecuteQuerySegmentedAsync(new TableQuery <User>(), null)).AsQueryable();
results = results.Where(x => x.IsDeleted == false).Where(x => x.Role != "admin").Where(x => x.RowKey != userParams.UserId).OrderBy(x => x.Name);
if ((!string.IsNullOrEmpty(userParams.Role)) && userParams.Team)
{
if (userParams.Role == "manager")
{
var newResults = await repo.GetMyTeamAsManager(userParams.UserId);
results = newResults.AsQueryable().OrderByDescending(x => x.Name);
}
else if (userParams.Role == "employee")
{
var newResults = await repo.GetMyTeamAsEmployee(userParams.Manager);
results = newResults.AsQueryable().Where(x => x.RowKey != userParams.UserId).Union(results.AsQueryable()
.Where(x => x.Name == userParams.Manager)).OrderByDescending(x => x.Name);
}
else
{
userParams.Role = null;
}
}
if (!string.IsNullOrEmpty(userParams.Search))
{
results = results.Where(x => x.Name.ToLower().Contains(userParams.Search.ToLower()) ||
x.Manager_ID.ToLower().Contains(userParams.Search.ToLower()) ||
x.Email.ToLower().Contains(userParams.Search.ToLower())
);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "desc":
results = results.OrderByDescending(u => u.Name);
break;
case "asc":
results = results.OrderBy(u => u.Name);
break;
case "man-asc":
results = results.OrderBy(u => u.Manager_ID);
break;
case "man-desc":
results = results.OrderByDescending(u => u.Manager_ID);
break;
default:
results = results.OrderBy(u => u.Name);
break;
}
}
if (results == null)
{
return(null);
}
var paginatedResult = PagedList <User> .Create(results, userParams.PageNumber, userParams.PageSize);
if (paginatedResult == null)
{
return(null);
}
return(paginatedResult);
}
public async Task <bool> SaveAll()
{
var repo = new TableStorageRepository();
return(await repo.SaveAll());
}
public void Delete <T>(T entity) where T : class
{
var repo = new TableStorageRepository();
repo.Delete(entity);
}
/////user apisss
public void Add <T>(T entity) where T : class
{
var repo = new TableStorageRepository();
repo.Add(entity);
}
