public async Task <bool> InitLogin()
{
if (UserNameVM == "" || UserNameVM == "")
{
return(false);
}
else
{
ScrumUser user = new ScrumUser()
{
User_Name = UserNameVM, User_Password = PasswordVM
};
ScrumUser loggedUser = await UsersPer.Login(user);
if (loggedUser != null)
{
if (loggedUser.User_Id != 0)
{
LeSingleton.LoggedUser = loggedUser;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
/// <summary>
/// Starter med at opdaterer knappen til at udføre en anden funktion end normalt.
/// Derefter udfylder vi felterne i Viewet så brugeren kan se hvad de er igang med at redigere.
/// </summary>
public void StartStoryEdit()
{
StoryButton = "Edit";
CreateStoryCommand = new RelayCommand(Edit);
Story_PointsVM = SelectedStory.Story_Points;
Story_descriptionVM = SelectedStory.Story_description;
Story_PriorityVM = SelectedStory.Story_Priority;
Story_NameVM = SelectedStory.Story_Name;
foreach (Category cat in CategoriesForStory)
{
if (cat.Category_Id == SelectedStory.Category.Category_Id)
{
Story_CategoryVM = cat;
}
}
AssigneeVM = new ScrumUser()
{
User_Id = 0
};
foreach (ScrumUser su in UsersInProject)
{
if (su.User_Id == SelectedStory.Story_Asignee.User_Id)
{
AssigneeVM = su;
}
}
}
public async static Task <ScrumUser> Login(ScrumUser user)
{
HttpClientHandler handler = new HttpClientHandler();
handler.UseDefaultCredentials = true;
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(Serverurl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("aplication/json"));
try
{
var response = await client.GetAsync($"api/ScrumUsers?userName={user.User_Name}&userPassword={user.User_Password}");
if (response.IsSuccessStatusCode)
{
return(response.Content.ReadAsAsync <ScrumUser>().Result);
}
else
{
return(null);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public List <ScrumUser> Get()
{
List <ScrumUser> scUsers = new List <ScrumUser>();
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
string queryString = $"SELECT User_Id, User_Name FROM Users";
SqlCommand command = new SqlCommand(queryString, connection);
command.Connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
ScrumUser sc = new ScrumUser()
{
User_Id = (int)reader["User_Id"],
User_Name = (string)reader["User_Name"]
};
scUsers.Add(sc);
}
command.Connection.Close();
}
return(scUsers);
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, ProductBacklogItem resource)
{
BacklogItem = await _dbContext.ProductBackLogItems.Include(prop => prop.Team)
.Include(prop => prop.Product).ThenInclude(p => p.ProductManager).Where(i => i.Id == resource.Id).FirstOrDefaultAsync();
if (context.User.IsInRole(Roles.Admin) || resource.Product.ProductManager.UserName == context.User.Identity.Name)
{
context.Succeed(requirement);
return;
}
User = await _dbContext.Users.Where(u => u.UserName == context.User.Identity.Name).FirstOrDefaultAsync();
if (User == null)
{
context.Fail();
return;
}
if (requirement.Name == Operations.Update.Name)
{
await CanUpdateBacklogTask(context, requirement);
}
else if (requirement.Name == Operations.View.Name)
{
await CanViewBacklogTask(context, requirement);
}
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, ScrumTeam resource)
{
if (context.User.IsInRole(Roles.Admin))
{
context.Succeed(requirement);
return;
}
User = await _dbContext.Users.Where(u => u.UserName == context.User.Identity.Name).FirstOrDefaultAsync();
if (requirement.Name == Operations.View.Name)
{
await CanViewTeam(context, requirement, resource);
}
}
public void HandleUncheck(string name)
{
ScrumUser u = null;
foreach (ScrumUser selectedUser in selectedUsers)
{
if (name == selectedUser.User_Name)
{
u = selectedUser;
}
}
if (u != null)
{
selectedUsers.Remove(u);
}
}
/// <summary>
/// Bruges til at restte viewet tilbage til normalen
/// </summary>
public void StoryReset()
{
StoryButton = "Create";
CreateStoryCommand = new RelayCommand(CreateStory);
Story_PointsVM = 0;
Story_descriptionVM = "";
Story_PriorityVM = 0;
Story_NameVM = "";
Story_CategoryVM = null;
AssigneeVM = new ScrumUser()
{
User_Id = 0
};
SelectedStory = null;
}
private async Task LoadSharedKeyAndQrCodeUriAsync(ScrumUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, Product resource)
{
if (context.User.IsInRole(Roles.Admin) || resource.ProductManager.UserName == context.User.Identity.Name)
{
context.Succeed(requirement);
return;
}
User = await _dbContext.Users.Where(u => u.UserName == context.User.Identity.Name).FirstOrDefaultAsync();
if (User == null)
{
context.Fail();
return;
}
if (requirement.Name == Operations.View.Name)
{
await CanViewBacklog(context, requirement, resource);
}
}
public CreateStoryVM()
{
Stories = new ObservableCollection <Story>();
CreateStoryCommand = new RelayCommand(CreateStory);
CreateCatCommand = new RelayCommand(CreatCategory);
CategoriesForStory = new ObservableCollection <Category>();
LeSingleton = Singleton.Instance;
AssigneeVM = new ScrumUser()
{
User_Id = 0
};
UsersInProject = new ObservableCollection <ScrumUser>();
StoryButton = "Create";
CatButton = "Create";
SletButtonState = "Collapsed";
SletCatCommand = new RelayCommand(DeleteCategory);
AnnullerCatCommand = new RelayCommand(ResetCategory);
RemoveStoryCommand = new RelayCommand(RemoveStory);
Load();
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new ScrumUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
private async Task CreateRoles(IServiceProvider serviceProvider)
{
//adding custom roles
var RoleManager = serviceProvider.GetRequiredService <RoleManager <ScrumRole> >();
var UserManager = serviceProvider.GetRequiredService <UserManager <ScrumUser> >();
IdentityResult roleResult;
foreach (var role in Roles.getRoles())
{
var roleExist = await RoleManager.RoleExistsAsync(role);
if (!roleExist)
{
roleResult = await RoleManager.CreateAsync(new ScrumRole(role));
}
}
//creating a super user who could maintain the web app
var poweruser = new ScrumUser
{
UserName = Configuration.GetSection("UserSettings")["UserEmail"],
Email = Configuration.GetSection("UserSettings")["UserEmail"]
};
string UserPassword = Configuration.GetSection("UserSettings")["UserPassword"];
var _user = await UserManager.FindByEmailAsync(Configuration.GetSection("UserSettings")["UserEmail"]);
if (_user == null)
{
var createPowerUser = await UserManager.CreateAsync(poweruser, UserPassword);
if (createPowerUser.Succeeded)
{
//here we tie the new user to the "Admin" role
await UserManager.AddToRoleAsync(poweruser, Roles.Admin);
}
}
await InjectSampleData(serviceProvider);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ScrumUser {
UserName = Input.Email, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public ScrumUser Get(string userName, string userPassword)
{
ScrumUser scUser = new ScrumUser();
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
string queryString = $"SELECT User_Id, User_Name FROM Users WHERE User_Name = '{userName}' AND User_Password = '******'";
SqlCommand command = new SqlCommand(queryString, connection);
command.Connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
scUser.User_Name = (string)reader["User_Name"];
scUser.User_Id = (int)reader["User_Id"];
}
command.Connection.Close();
}
return(scUser);
}
private async Task InjectSampleData(IServiceProvider serviceProvider)
{
var RoleManager = serviceProvider.GetRequiredService <RoleManager <ScrumRole> >();
var UserManager = serviceProvider.GetRequiredService <UserManager <ScrumUser> >();
var jane = Configuration.GetSection("SampleData")["UserEmail"];
var janepass = Configuration.GetSection("SampleData")["UserPassword"];
var prodname = Configuration.GetSection("SampleData")["ProductName"];
var proddesc = Configuration.GetSection("SampleData")["ProdDesc"];
var janeuser = new ScrumUser
{
UserName = jane,
Email = jane
};
var _user = await UserManager.FindByEmailAsync(jane);
if (_user == null)
{
var createUser = await UserManager.CreateAsync(janeuser, janepass);
if (createUser.Succeeded)
{
await UserManager.AddToRoleAsync(janeuser, Roles.Product_Owner);
var product = new Product
{
Name = prodname,
Description = proddesc,
ProductManager = janeuser
};
var context = serviceProvider.GetService <ScrumContext>();
context.Products.Add(product);
context.SaveChanges();
}
else
{
janeuser = null;
}
}
else
{
var context = serviceProvider.GetService <ScrumContext>();
var team = new ScrumTeam()
{
TeamName = "Sample Team"
};
var exists = context.ScrumTeams.Where(sc => sc.TeamName == team.TeamName).Include(sc => sc.UserTeams).ToList();
if (exists == null || exists.Count == 0)
{
var user_team = new ScrumUserTeam()
{
User = _user,
Team = team
};
context.ScrumTeams.Add(team);
context.ScrumUserTeams.Add(user_team);
context.SaveChanges();
}
}
}
