public IActionResult Administration()
{
var users = this.signInManager
.UserManager
.Users
.Select(u => new UserViewModel()
{
Id = u.Id,
Username = u.UserName,
})
.ToList();
foreach (var userViewModel in users)
{
var user = this.signInManager
.UserManager
.FindByIdAsync(userViewModel.Id)
.GetAwaiter()
.GetResult();
userViewModel.IsAdmin = this.signInManager
.UserManager
.IsInRoleAsync(user, "Administrator")
.GetAwaiter()
.GetResult();
}
var administrationViewModel = new AdministrationViewModel
{
Users = users
};
return(View(administrationViewModel));
}
public async Task <IActionResult> SignUp(AdministrationViewModel model)
{
if (ModelState.IsValid)
{
AppUser user = new AppUser
{
UserName = model.SignUpModel.FirstName,
FirstName = model.SignUpModel.FirstName,
LastName = model.SignUpModel.LastName,
Email = model.SignUpModel.Email,
Address = model.SignUpModel.Address,
ZipCode = model.SignUpModel.ZipCode,
City = model.SignUpModel.City
};
IdentityResult result = await _userManager.CreateAsync(user, model.SignUpModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
// GET: Administration
public ActionResult Index(string section = "users")
{
ViewBag.CurrentPage = "Admin";
var viewmodel = new AdministrationViewModel {
Users = new List <SiteUserModel>()
};
viewmodel.SectionName = section.ToLower();
if (section == "users")
{
var usermanager = new AppUserManager(_userStore);
foreach (var user in _userStore.Users.ToList())
{
SiteUserModel siteuser = AutoMapper.Mapper.Map <SiteUserModel>(user);
siteuser.UserRoles = usermanager.GetRoles(user.Id).ToArray();
viewmodel.Users.Add(siteuser);
}
}
else
{
viewmodel.SiteSettings = _acidRepos.GetSettings();
}
return(View(viewmodel));
}
public async Task <IActionResult> Administration(string userName, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
ViewData["UserName"] = userName;
var user = await _userManager.FindByNameAsync(userName);
var managers = _managerData.GetManagers(user.Id).Select(m => m.Id).ToList();
var allManagers = await _userManager.GetUsersInRoleAsync("Manager");
allManagers = allManagers.Where(m => !m.IsDeleted).ToList();
var managerViewModels = new List <UserViewModel>();
foreach (var manager in allManagers.Where(m => m.Id != user.Id).ToList())
{
managerViewModels.Add(new UserViewModel {
Id = manager.Id,
FirstName = manager.FirstName,
LastName = manager.LastName
});
}
var model = new AdministrationViewModel
{
Role = _userManager.GetRolesAsync(user).Result.FirstOrDefault(),
Roles = _roleManager.GetRolesSelectList(),
Managers = managerViewModels,
ManagerIds = managers,
IsBanned = user.IsBanned,
BanEnd = user.BanEndTime
};
return(View(model));
}
public ActionResult AddUser(AdministrationViewModel model)
{
if (!ModelState.IsValid)
{
Trace.WriteLine("TAFIDITRA ATO : FORMULAIRE INVALIDE");
ViewBag.ErrorMessage = "Formulaire Invalide";
return(RedirectToAction("Administration", "Administration"));
}
try
{
Trace.WriteLine("TAFIDITRA ATO : MANDE TSARA");
var user = new USER
{
NOMUSER = model.Nom,
PRENOMUSER = model.Prenom,
LOGINUSER = model.Login,
MDP = Utilities.GetHashString(model.Password),
EMAIL = model.Email,
TELINSCRIPTION = model.Telephone,
IDPROFIL = model.Profil,
DATEPROFIL = DateTime.Now,
};
_userService.InsertUser(user);
return(RedirectToAction("Administration"));
}
catch (Exception ex)
{
Trace.WriteLine("TAFIDITRA ATO : MISY ERREUR :" + ex.InnerException);
ViewBag.ErrorMessage = ex.Message;
return(RedirectToAction("Administration", "Administration"));
}
}
public ActionResult Create(AdministrationViewModel administrationVM, int projectid)
{
if (!_projectuservalidationservice.UserCanEditProject(projectid))
{
ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
return(View("Error"));
}
if (ModelState.IsValid)
{
var unit = db.Units.Find(administrationVM.unitID);
var factor = unit.ConversionFactor;
Administration administration = new Administration
{
StartTime = Convert.ToInt32(administrationVM.StartTime * factor),
EndTime = Convert.ToInt32(administrationVM.EndTime * factor),
ProcedureID = administrationVM.ProcedureID,
CreatedBy = (int)Membership.GetUser().ProviderUserKey,
LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey,
};
db.Administrations.Add(administration);
db.SaveChanges();
return(RedirectToAction("Index", new { procedureid = administrationVM.ProcedureID, projectid = administrationVM.ProjectID }));
}
return(View(administrationVM));
}
public async Task <IActionResult> All()
{
var model = new AdministrationViewModel();
var currentUser = await this.userManager.GetUserAsync(this.HttpContext.User);
var admins = await this.userService.GetAdmins(currentUser.Id);
var adminModels = admins.Select(x => Mapper.Map <UserViewModel>(x)).OrderBy(x => x.FirstName).ToList();
model.Admins = adminModels;
var agents = await this.userService.GetAgents();
var agentModels = agents.Select(x => Mapper.Map <UserViewModel>(x)).OrderBy(x => x.FirstName).ToList();
model.Agents = agentModels;
var clients = await this.userService.GetClients();
var clientModels = clients.Select(x => Mapper.Map <UserViewModel>(x)).OrderBy(x => x.FirstName).ToList();
model.Clients = clientModels;
return(this.View(model));
}
public AdministrationView()
{
InitializeComponent();
var vm = new AdministrationViewModel();
DataContext = vm;
}
public AdminPanelWindow()
{
InitializeComponent();
DataContext = new AdministrationViewModel();
foreach (var i in ((AdministrationViewModel)(DataContext)).difficulties)
{
Difficulties.Items.Add(i);
}
}
public ActionResult Administration(AdministrationViewModel model)
{
if (model == null)
{
model = new AdministrationViewModel();
}
model.ListUser = _userService.ListUserForTable();
model.ListProfil = _userService.ListProfil();
model.ListAcces = _userService.ListAcces();
return(View(model));
}
public MainPage()
{
this.InitializeComponent();
AutoMapperConfiguration.Configure();
Employees = new ObservableCollection <EmployeeModel>();
Client = new LocalClient();
AdministrationViewModel = new AdministrationViewModel();
}
public async Task <IActionResult> CreateMatch(AdministrationViewModel model)
{
await matchRepository.AddMatch(new Match
{
MatchDateTime = model.MatchDateTime,
ClubHomeName = model.ClubHomeName,
ClubAwayName = model.ClubAwayName,
LeagueId = model.LeagueId
});
return(await CreateViewModel());
}
public async Task <IActionResult> Index()
{
var viewModel = new AdministrationViewModel()
{
Users = new List <UserViewModel>()
};
var users = await _accountManager.GetAllUsersWithRoles();
viewModel.Users = users.Select(x => _mapper.Map <UserViewModel>(x)).ToList();
return(View(viewModel));
}
public static IMvvmBinder GetNewAdministrationView(object arg)
{
////IDataContext dc = new UnitTextConnectionDataContext();
IDataContext dc = new HVCC.Shell.Models.HVCCDataContext() as IDataContext;
IViewModel vm = new AdministrationViewModel(dc)
{
Caption = "Administration"
};
IView v = new HVCC.Shell.Views.AdministrationView(vm);
return(new MvvmBinder(dc, v, vm));
}
public NotesMenu(AdministrationViewModel adminViewModel)
{
InitializeComponent();
administrationViewModel = adminViewModel;
if (!adminViewModel.IsBattelleDevelopmentCompleteChecked)
{
SDgrid.Height = 0;
}
else
{
SDgrid.Height = 45;
}
}
public AdministrationController(IAdministrationRepository administrationRepository, ILeagueRepository leagueRepository,
IMatchRepository matchRepository, ITipRepository tipRepository, IPredictionRepository predictionRepository,
IAccountRepository accountRepository, IBetRepository betRepository)
{
this.administrationRepository = administrationRepository;
this.leagueRepository = leagueRepository;
this.matchRepository = matchRepository;
this.tipRepository = tipRepository;
this.predictionRepository = predictionRepository;
this.accountRepository = accountRepository;
this.betRepository = betRepository;
viewModel = new AdministrationViewModel();
}
// GET: Administration
public ActionResult Index()
{
AdministrationViewModel adminViewModel = new AdministrationViewModel();
adminViewModel.Accounts = new AdminAccountsViewModel();
adminViewModel.Accounts.Accounts = this.administrationProvider.GetAllAccounts();
adminViewModel.Reviews = new AdminReviewsViewModel();
adminViewModel.Reviews.Reviews = this.administrationProvider.GetAllReviews();
adminViewModel.Words = new AdminWordsViewModel();
adminViewModel.Words.Words = this.administrationProvider.GetAllWords();
return(this.View(adminViewModel));
}
public ActionResult Reports()
{
var tday = _ren.TeachableDays.OrderByDescending(x => x.TeachableDays).Take(10);
var startDay = tday.First().TeachableDays;
var tenEntryDaysBack = _ren.TeachableDays.Where(x => x.TeachableDays <= startDay).OrderByDescending(x => x.TeachableDays).Take(10).ToList().Last().TeachableDays;
AdministrationViewModel avm = new AdministrationViewModel();
var enteredBadgeString = User.Identity.Name;
var selectedAdmin = _db.MinutesAdmins.FirstOrDefault(i => i.BADGE_NUM == enteredBadgeString);
ViewBag.Name = selectedAdmin.FIRST_NAME + " " + selectedAdmin.LAST_NAME;
var sumReports = _db.EnteredPeMinutes.Where(x => x.InstructionTime >= tenEntryDaysBack && x.InstructionTime < startDay).OrderBy(x => x.School).DistinctBy(x => x.TeacherName).ToList(); // select all minutes from the school the principal belongs to
var allReports = _db.EnteredPeMinutes.Where(x => x.InstructionTime >= tenEntryDaysBack && x.InstructionTime < startDay).OrderBy(x => x.School).ToList();
foreach (var item in sumReports)
{
ReportView rv = new ReportView
{
TeacherName = item.TeacherName,
SchoolName = item.School.Substring(0, item.School.Length - 18),
Minutes = allReports.Where(x => x.TeacherName == item.TeacherName).Sum(x => x.Minutes)
};
rv.Percentage = ((float)rv.Minutes / 2) + "%";
avm.Reports.Add(rv);
}
foreach (var item in allReports)
{
ReportList rl = new ReportList
{
TeacherName = item.TeacherName,
SchoolName = item.School.Substring(0, item.School.Length - 18),
Minutes = item.Minutes
};
var time = Convert.ToDateTime(item.InstructionTime);
rl.InstructionTime = time.ToShortDateString();
avm.ListReports.Add(rl);
}
avm.Reports = avm.Reports.ToList();
avm.ListReports = avm.ListReports.ToList();
return(View(avm));
}
public IActionResult Index()
{
var allCompany = _companyDatastore.GetAll();
var allContact = allCompany.SelectMany(x => _contactDatastore.ByCompany(x.Id));
var allUsage = allContact.SelectMany(x => _usageDatastore.ByContact(x.Id));
var viewModel = new AdministrationViewModel
{
Company = allCompany.ToList(),
Contact = allContact.ToList(),
Usage = allUsage.ToList()
};
return(View(viewModel));
}
// GET: Administration
public ActionResult Index()
{
//TODO: Em um futuro, persistir os Menus no banco vinculando com acessos do usuário
var model = new AdministrationViewModel()
{
Menus = new List <MenuItem>()
{
new MenuItem("Gerenciar Acessos", "#3BA89B", "Manage", "Permissions", "permissions.png"),
new MenuItem("Gerenciar Mídias", "#3BA89B", "Manage", "Media", "permissions.png"),
new MenuItem("Gerenciar Cadastros", "#3BA89B", "Manage", "Academic", "permissions.png")
}
};
return(View(model));
}
// GET: Administration
public ActionResult Index(string selectedDate)
{
// Find the first day teachable day by default
var startDay = _ren.TeachableDays.OrderByDescending(x => x.TeachableDays).First().TeachableDays;
if (!string.IsNullOrEmpty(selectedDate))
{
// Use the input variable if selected
startDay = Convert.ToDateTime(selectedDate);
}
// Take 10 teachable days back from the startDay
var tenEntryDaysBack = _ren.TeachableDays.Where(x => x.TeachableDays <= startDay).OrderByDescending(x => x.TeachableDays).Take(10).ToList().Last().TeachableDays;
var enteredBadgeString = User.Identity.Name;
var selectedAdmin = _db.MinutesAdmins.FirstOrDefault(i => i.BADGE_NUM == enteredBadgeString);
ViewBag.Name = selectedAdmin.FIRST_NAME + " " + selectedAdmin.LAST_NAME;
var adminView = _db.EnteredPeMinutes.Where(x => x.InstructionTime >= tenEntryDaysBack && x.InstructionTime <= startDay && x.School.Contains("Elem")).OrderBy(x => x.School); // select all minutes from the school the principal belongs to
var avm = new AdministrationViewModel();
var numberTeachers = _ren.PEMinutesTeacherCounts.Where(x => x.Organization_Name.Contains("Elem")).ToList();
foreach (var item in numberTeachers)
{
var tc = new TeacherCount();
var schoolfullname = item.Organization_Name;
tc.TotalTeachers = item.TEACHER;
var schoolname = schoolfullname.Substring(0, schoolfullname.Length - 18);
tc.ShortSchoolName = schoolname;
var count = 0;
foreach (var teach in adminView.Where(x => x.School == item.Organization_Name).GroupBy(x => x.TeacherName))
{
var sum = teach.Sum(x => x.Minutes);
if (sum >= 200)
{
count++;
}
}
tc.MeetReq = count;
tc.Percent = ((float)count / item.TEACHER) * 100;
tc.Percent = (float)Math.Round((double)tc.Percent, 2);
avm.TeachCount.Add(tc);
}
avm.Date = startDay.ToShortDateString();
avm.DateStart = tenEntryDaysBack.ToShortDateString();
avm.DateEnd = startDay.ToShortDateString();
avm.TeachCount = avm.TeachCount.ToList();
return(View(avm));
}
public AdministrationController(CompositionContainer container
, ShellViewModel shellViewModel
, AdministrationViewModel _AdministrationViewModel
, AdminTatScheduleViewModel _tatScheduleViewModel
, VolumeAdjustmentsViewModel _volumeAdjustmentsViewModel
, AdminLinksViewModel _adminLinksViewModel
, PasswordChangeViewModel _passwordChangeViewMod
)
{
this.container = container;
this.administrationViewModel = _AdministrationViewModel;
tatScheduleViewModel = _tatScheduleViewModel;
passwordChangeViewModel = _passwordChangeViewMod;
adminLinksViewModel = _adminLinksViewModel;
volumeAdjustmentsViewModel = _volumeAdjustmentsViewModel;
this.shellViewModel = shellViewModel;
}
public IActionResult Index()
{
var account = this.accountsService.GetFirstAccount();
var accountModel = new SellAccountInputModel();
var application = this.jobsService.GetFirstApplication();
var applicationModel = new ApplicationViewModel();
if (account != null)
{
accountModel = new SellAccountInputModel
{
ChampionsCount = account.ChampionsCount,
SkinsCount = account.SkinsCount,
BlueEssence = account.BlueEssence,
RiotPoints = account.RiotPoints,
Username = account.Username,
Password = account.Password,
Region = account.Region,
};
}
if (application != null)
{
applicationModel = new ApplicationViewModel
{
UserId = application.UserId,
Age = application.Age,
Name = application.Name,
Country = application.Country,
Position = application.Position,
Rank = application.Rank,
Champions = application.Champions,
Description = application.Description,
};
}
var viewModel = new AdministrationViewModel
{
Account = accountModel,
Application = applicationModel,
};
return(this.View(viewModel));
}
public async Task <IActionResult> CreateRoleAsync(AdministrationViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administration"));
}
}
return(View(model));
}
public ActionResult Index()
{
var plugins = _pluginManager.ListPlugins();
var viewModel = new AdministrationViewModel();
viewModel.Plugins = plugins
.Select(p => new PluginViewModel()
{
PackageId = p.PackageId,
PackageVersion = p.PackageVersion,
PackageDescription = p.PackageDescription,
IsInstalled = p.IsInstalled
})
.ToList();
return(View(viewModel));
}
public async Task <IActionResult> CreatePrediction(AdministrationViewModel model)
{
Prediction predictionAdded = await administrationRepository.AddPredictionAsync(new Prediction
{
Odds = model.Odds,
Chance = model.Chance,
MatchId = model.MatchId,
TipId = model.TipId
});
await administrationRepository.AddUserRolePredictionAsync(new UserRolePredictions
{
UserRoleId = model.RoleId,
PredictionId = predictionAdded.PredictionId
});
return(await CreateViewModel());
}
public ActionResult Administration()
{
var currentUser = HttpContext.User as CustomUser;
var id = currentUser?.UserId ?? default(int);
var customer = _customerService.GetWorkerByUserId(id);
var address = new AdministrationViewModel
{
Administration = customer.Administration.Name,
AdministrationContactName = customer.Administration.Contact.GetFullName(),
AdministrationPhone = customer.Administration.Phone,
Description = customer.Administration.Url,
Email = customer.Administration.Email,
Address = customer.Administration.Address.City + ", " + customer.Administration.Address.Street + ", " +
customer.Administration.Address.HouseNameRoomNumber + " "
};
return(View(address));
}
//
// GET: /Administration/Create
public ActionResult Create(int procedureid, int projectid)
{
if (!_projectuservalidationservice.UserCanEditProject(projectid))
{
ViewBag.ErrorMessage = "Access Denied. Please contact administrator for further assistance.";
return(View("Error"));
}
ViewBag.ProcedureID = new SelectList(db.Procedures, "ProcedureID", "ProcedureLabel");
AdministrationViewModel administrationVM = new AdministrationViewModel
{
ProcedureID = procedureid,
unitList = new SelectList(db.Units.Where(u => u.Status == "Current" && u.SIUnite.QuantityName == "Time").AsEnumerable(), "UnitID", "UnitSymbol"),
};
ViewBag.projectid = projectid;
ViewBag.procedureid = procedureid;
return(View(administrationVM));
}
public async Task <IActionResult> Login(AdministrationViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
AppUser user = await _userManager.FindByEmailAsync(model.LoginModel.Email);
if (user != null)
{
await _signInManager.SignOutAsync();
Microsoft.AspNetCore.Identity.SignInResult result =
await _signInManager.PasswordSignInAsync(user, model.LoginModel.Password, false, false);
if (result.Succeeded)
{
return(Redirect(returnUrl ?? "/"));
}
}
ModelState.AddModelError(nameof(AdministrationViewModel.LoginModel.Email), "Invalid user or password");
}
return(View(model));
}
public async Task <IActionResult> AdminPanel(int page = 1)
{
var user = await Authorize();
if (user == null) //Если пользователь не вошел, перенаправляем на страницу авторизации
{
return(RedirectToAction("Login", "Auth", new { fallbackUrl = HttpContext.Request.Path }));
}
if (!user.Roles.Any(r => r.Name == "Администратор")) //Если не соответствует роли, выдаем сообщение
{
return(Unauthorized());
}
List <User> users = await UserRepository.GetAll().OrderByDescending(u => u.Id).Skip((page - 1) * 5).Take(5).ToListAsync(); //Список пользователей по страницам
var vm = new AdministrationViewModel
{
Users = users,
Page = new PagingViewModel(page, await UserRepository.GetAll().CountAsync(), 5) //Задание модели постраничного просмотра
};
return(View(vm));
}
