public async Task <IViewComponentResult> InvokeAsync()
{
var userId = UserClaimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
var dto = _itemService.GetShortMyAuctions(userId);
return(View(dto));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userId = UserClaimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
var dto = await _itemService.GetShortCustomerBestBidsAsync(userId);
return(View(dto));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userId = UserClaimsPrincipal.FindFirstValue(ClaimTypes.NameIdentifier);
var user = await this.users.ByIdAsync <UserNavServiceModel>(userId);
return(View(user));
}
public async Task <IViewComponentResult> InvokeAsync()
{
bool isAuthenticated = false;
bool isAdmin = false;
var role = "Passenger";
if (User.Identity.IsAuthenticated)
{
isAuthenticated = true;
if (UserClaimsPrincipal.HasClaim("AccessLevel", "Admin"))
{
isAdmin = true;
role = "Admin";
}
}
var contactInfo = new FooterObject
{
Email = _config.GetSection("ContactUs").GetValue <string>("Email"),
ContactNumber = _config.GetSection("ContactUs").GetValue <string>("ContactNumber"),
IsAuthenticated = isAuthenticated,
IsAdmin = isAdmin,
Name = UserClaimsPrincipal.Identity.Name,
Role = role
};
return(View(contactInfo));
}
public async Task <IViewComponentResult> InvokeAsync()
{
bool isAuthenticated = false;
bool isAdmin = false;
var role = "Passenger";
if (User.Identity.IsAuthenticated)
{
isAuthenticated = true;
if (UserClaimsPrincipal.HasClaim("AccessLevel", "Admin"))
{
isAdmin = true;
role = "Admin";
}
}
var thisUser = new NavBarObject
{
IsAuthenticated = isAuthenticated,
IsAdmin = isAdmin,
Name = UserClaimsPrincipal.Identity.Name,
Role = role
};
return(View(thisUser));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userId = UserClaimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
var dto = _customerService.GetContact(userId);
var model = _mapper.Map <ContactDTO, ContactViewModel> (dto);
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userID = UserClaimsPrincipal.FindFirstValue(ClaimTypes.NameIdentifier);
var currentUser = await this.service.GetUserAsync(userID);
bool isChangedPass = currentUser.FirstLog == true;
return(View(isChangedPass));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userID = UserClaimsPrincipal.FindFirstValue(ClaimTypes.NameIdentifier);
var currentUser = await this.accountsService.GetUserAsync(userID);
bool exists = currentUser != null;
return(View(exists));
}
public async System.Threading.Tasks.Task <IViewComponentResult> InvokeAsync()
{
int orderNum = 0;
if (HttpContext.User.Identity.IsAuthenticated)
{
orderNum = await httpClientService.CountUserOrderDetailAsync(UserClaimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value);
}
return(View(orderNum));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userID = UserClaimsPrincipal.FindFirstValue(ClaimTypes.NameIdentifier);
var currentUser = await this.accountsService.GetUserAsync(userID);
bool isExpired = currentUser.Expired == null || currentUser.Expired < DateTime.Now;
return(View(isExpired));
}
private UserViewModel GetUser(int id)
{
var user = new UserViewModel
{
Name = User.Identity.Name,
Email = UserClaimsPrincipal.FindFirst(c => c.Type == ClaimTypes.Email).Value
};
return(user);
}
public async Task <IViewComponentResult> InvokeAsync()
{
if (User.Identity.IsAuthenticated)
{
var userEmailClaim = UserClaimsPrincipal.FindFirst(ClaimTypes.Email);
string userEmail = userEmailClaim.Value;
return(View("LoggedIn", userEmail));
}
return(View());
}
//此方法由视图组件调用
public IViewComponentResult Invoke()
{
ViewBag.CurrentUser = UserClaimsPrincipal.FindFirstValue(ClaimTypes.Name);
string roleKeys = UserClaimsPrincipal.FindFirstValue(ClaimTypes.Role);
//缓存权限集合
var dtos = appCache.GetCacheAsync <PermissionDto>(roleKeys, async() =>
{
var model = await roleService.SingleAsync(
express: inf => inf.Code.Contains(roleKeys),
include: inf => inf.Include(r => r.RoleAuthorizes).ThenInclude(p => p.PermissionInformation));
return(model.PermssionDtos);
}).Result;
return(View(dtos));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var userId = UserClaimsPrincipal?.GetId();
var detailsCount = 0;
if (string.IsNullOrEmpty(userId))
{
return(View(detailsCount));
}
var basket = await _basketService.GetBasketForUserAsync(userId);
detailsCount = basket.OrderDetails.Sum(d => d.Quantity);
return(View(detailsCount));
}
public async Task <IViewComponentResult> InvokeAsync()
{
string userId = UserClaimsPrincipal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (userId != null)
{
ApplicationUser currentUser = await _userManager.FindByIdAsync(userId);
Patron p = _db.Patrons.Include(x => x.User).FirstOrDefault(x => x.User.Id == currentUser.Id);
return(View(p.Id));
}
else
{
return(View(0));
}
}
private async Task <IList <DashboardSideMenu> > GetSideMenu()
{
SideMenuManager mgr = new SideMenuManager();
string UserRoles = UserClaimsPrincipal.FindFirst(ClaimTypes.Role)?.Value;
string[] currentRoles = UserRoles.Split(",");
IList <DashboardSideMenu> listitem;
if (Array.IndexOf(currentRoles, "Super Admin") > -1)// do not check permission for erp admin super roles.
{
listitem = await mgr.GetAllSideMenu(null, 0);
}
else
{
listitem = await mgr.GetSideMenuByRole(UserRoles, 0);
}
return(listitem);
}
/// <summary>
/// Check if user can have access to the view component with his permissions.
/// </summary>
/// <returns><c>true</c>, if view component rights was valided, <c>false</c> otherwise.</returns>
public bool ValidViewComponentRights()
{
string[] claims = null;
string[] roles = null;
IEnumerable <ViewComponentAuthorizeAttribute> attributes = this.GetType().GetCustomAttributes <ViewComponentAuthorizeAttribute>();
if (!attributes.Any())
{
return(true);
}
foreach (ViewComponentAuthorizeAttribute attribute in attributes)
{
// Get claims
claims = attribute.GetClaims();
if (claims != null)
{
foreach (string claim in claims)
{
if (UserClaimsPrincipal.HasClaim(c => c.Value == claim))
{
return(true);
}
}
}
// Get roles
if (roles != null)
{
foreach (string role in roles)
{
if (User.IsInRole(role))
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Has the required claim.
/// </summary>
/// <returns><c>true</c>, if required claim was hased, <c>false</c> otherwise.</returns>
public bool HasRequiredClaim()
{
int requiredPermissionId = 0;
if (_requiredClaims == null)
{
return(false);
}
foreach (PermissionInfo permission in _requiredClaims)
{
if (permission.Name == ModuleConfiguration.GrantedAccessPermission ||
(UserClaimsPrincipal.HasClaim(v => v.Type == ModuleConfiguration.ModulePermissionType &&
int.TryParse(v.Value, out requiredPermissionId) &&
requiredPermissionId == permission.PermissionId)))
{
return(true);
}
}
return(false);
}
public async Task <IViewComponentResult> InvokeAsync()
{
List <Product> allProducts = _context.Products.Include(p => p.Brand).ToList <Product>();
User user = await _context.Users.FirstAsync(u => u.Email.Equals(UserClaimsPrincipal.FindFirstValue(ClaimTypes.Email)));
var productsOrderedByUser = from p in _context.Products.Include(b => b.Brand)
from o in _context.Order.Where(o => o.UserId == user.UserId)
where o.OrderProducts.Any(op => op.ProductId == p.ProductId)
select p;
if (allProducts.Count() < 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", new List <Product>())));
}
if (productsOrderedByUser.Count() == 0 && allProducts.Count() >= 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", allProducts.OrderBy(x => x.ProductPrice).Take(3))));
}
double minPrice = productsOrderedByUser.Min(p => p.ProductPrice);
double maxPrice = productsOrderedByUser.Max(p => p.ProductPrice);
string mostFrequentBrand = productsOrderedByUser.ToList()
.GroupBy(q => q.Brand.BrandName)
.OrderByDescending(gp => gp.Count())
.First()
.Select(g => g.Brand.BrandName).First().ToString();
List <string> orderedTypes = productsOrderedByUser
.GroupBy(q => q.ProductType)
.Select(p => p.Key).ToList <string>();
List <Product> recommendedProducts = new List <Product>();
foreach (Product item in allProducts)
{
if (item.ProductPrice >= minPrice &&
item.ProductPrice <= maxPrice &&
item.Brand.Equals(mostFrequentBrand) &&
!orderedTypes.Contains(item.ProductType))
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
}
foreach (Product item in allProducts)
{
if (item.Brand.Equals(mostFrequentBrand) &&
!orderedTypes.Contains(item.ProductType) &&
!recommendedProducts.Contains(item) &&
!productsOrderedByUser.Contains(item))
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
}
if (recommendedProducts.Count() < 3)
{
foreach (Product item in allProducts)
{
if (!orderedTypes.Contains(item.ProductType) &&
!recommendedProducts.Contains(item) &&
!productsOrderedByUser.Contains(item))
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
}
foreach (Product item in allProducts)
{
if (!recommendedProducts.Contains(item) &&
!productsOrderedByUser.Contains(item) &&
item.Brand.Equals(mostFrequentBrand))
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
}
foreach (Product item in allProducts)
{
if (!recommendedProducts.Contains(item) &&
!productsOrderedByUser.Contains(item))
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
}
}
foreach (Product item in allProducts)
{
recommendedProducts.Add(item);
if (recommendedProducts.Count() == 3)
{
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
}
return(await Task.FromResult((IViewComponentResult)View("Default", recommendedProducts)));
}
