Esempio n. 1
0
        /// <summary>
        /// Execute the performance middleware logic.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="appContext"></param>
        /// <param name="loggerFactory"></param>
        /// <returns></returns>
        public async Task Invoke(HttpContext context,
                                 Services.WcmsAppContext appContext,
                                 ILoggerFactory loggerFactory)
        {
            // Special case...
            if (context?.Request?.Path.Value == "/flush")
            {
                // Flush the performance file...
                appContext?.FlushPerfLog();
                await context.Response.WriteAsync("Ok\r\n");

                return;
            }

            // Start performance logging...
            appContext?.StartPerfLog();

            ILogger log = loggerFactory?.CreateLogger("Performance" /*typeof(PerformanceMiddleware).FullName*/);

            log?.LogInformation(">>> \"{0}\"...",
                                context?.Request?.Path.Value?.ToString());
            {
                // Call next middleware...
                await _next(context);
            }
            // Trace process duration...
            log?.LogInformation("<<< \"{0}\" processed in {1} milliseconds.",
                                context?.Request?.Path.Value?.ToString(),
                                appContext?.ElapsedMilliseconds());

            // Write to the perfomance file...
            appContext?.WritePerfLog(context?.Request?.Path.Value);
        }
Esempio n. 2
0
        /// <summary>
        /// Convert filter got from a request.
        /// </summary>
        /// <param name="appContext"></param>
        /// <param name="filters"></param>
        /// <returns></returns>
        public static Dictionary <string, object> ConvertFilter(Services.WcmsAppContext appContext, Dictionary <string, string> filters)
        {
            Dictionary <string, object> fltrs = new Dictionary <string, object>();

            if (filters != null)
            {
                foreach (KeyValuePair <string, string> filter in filters)
                {
                    if (filter.Key != null && filter.Value != null)
                    {
                        if (filter.Key == QueryFilter.Title)
                        {
                            fltrs.Add(QueryFilter.Title, WebUtility.HtmlEncode(filter.Value));
                        }
                        else if (filter.Key.StartsWith(QueryFilter.Group) == true)
                        {
                            int groupId = 0;
                            if (int.TryParse(filter.Value, out groupId) == true)
                            {
                                fltrs.Add(QueryFilter.Group, groupId);
                            }
                        }
                    }
                }
            }
            return(fltrs);
        }
Esempio n. 3
0
 /// <summary>
 /// Base controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public BaseController(Services.WcmsAppContext appContext)
 {
     // Save the application context...
     AppContext = appContext;
     // Trace...
     _Log = AppContext?.LoggerFactory?.CreateLogger(this.GetType().Name);
     _Log?.LogDebug("BaseController: {0}", this.GetType().Name);
 }
Esempio n. 4
0
        public async Task Invoke(HttpContext context, Services.WcmsAppContext appContext)
        {
            if (appContext == null)
            {
                throw new InvalidOperationException("Invalid context");
            }
            //appContext.Host = context.Request.Host;

            /*var appContext = context.RequestServices.GetService<WcmsAppContext>();
             * if (appContext.RequestId != null)
             * {
             *  throw new InvalidOperationException("RequestId should be null here");
             * }
             * var requestId = context.Request.Headers["RequestId"];
             * appContext.RequestId = requestId;*/

            await _next(context);
        }
Esempio n. 5
0
        /// <summary>
        /// Count users.
        /// </summary>
        /// <param name="appContext"></param>
        /// <param name="filters"></param>
        /// <returns></returns>
        public static async Task <int> Count(Services.WcmsAppContext appContext, Dictionary <string, object> filters)
        {
            DataSorting orderBy = DataSorting.Validation;
            // Build the query...
            var query = _GetQuery(appContext, filters, ref orderBy);

            if (query == null)
            {
                return(0);
            }
            else
            {
                // Trace performance...
                appContext?.AddPerfLog("UserAuthorizationHandler::Count::Query built");
                // Execute the query...
                int count = await query.CountAsync();

                // Trace performance...
                appContext?.AddPerfLog("UserAuthorizationHandler::Count::Query executed");
                // Exit...
                return(count);
            }
        }
Esempio n. 6
0
        public JsonUser(Services.WcmsAppContext AppContext, ApplicationUser user = null, bool forEdition = false)
        {
            ICollection <UserGroup>  dataGroups  = null;
            ICollection <UserRegion> dataRegions = null;

            // Set...
            if (user != null)
            {
                Id        = user.Id;
                Email     = user.Email;
                Cover     = user.GetCoverUrl();
                CoverCrop = user.GetCoverUrl().Replace("cover", "cover.crop");
                Enabled   = user.Enabled;
                //Claims = user.Claims;
                if (user.Claims != null)
                {
                    foreach (IdentityUserClaim <string> claim in user.Claims)
                    {
                        if (claim != null)
                        {
                            if (claim.ClaimType == UserClaimType.FirstName)
                            {
                                FName = claim.ClaimValue;
                            }
                            else if (claim.ClaimType == UserClaimType.LastName)
                            {
                                LName = claim.ClaimValue;
                            }
                            else if (claim.ClaimType == UserClaimType.Phone)
                            {
                                Phone = claim.ClaimValue;
                            }
                            else if (claim.ClaimType == UserClaimType.Zip)
                            {
                                Zip = claim.ClaimValue;
                            }
                        }
                    }
                }
                if ((dataGroups = user.UserGroups(AppContext)) != null)
                {
                    UserGroups = new List <JsonUserGroup>();
                    if (forEdition == false)
                    {
                        foreach (UserGroup group in dataGroups)
                        {
                            UserGroups.Add(new JsonUserGroup(group));
                        }
                    }
                    else
                    {
                        ICollection <SiteClaim> userGroups = AppContext.Site.GetGroups(AppContext?.User?.GroupsId());
                        if (userGroups != null)
                        {
                            foreach (SiteClaim stGrp in userGroups)
                            {
                                JsonUserGroup pstGrp = new JsonUserGroup(user, stGrp);
                                foreach (UserGroup group in dataGroups)
                                {
                                    if (group.GroupId == stGrp.Id)
                                    {
                                        pstGrp.Checked = true;
                                        break;
                                    }
                                }
                                UserGroups.Add(pstGrp);
                            }
                        }
                    }
                }
                if ((dataRegions = user.UserRegions(AppContext)) != null)
                {
                    UserRegions = new List <JsonUserRegion>();
                    if (forEdition == false)
                    {
                        foreach (UserRegion region in dataRegions)
                        {
                            UserRegions.Add(new JsonUserRegion(region));
                        }
                    }
                    else
                    {
                        foreach (SiteClaim stReg in AppContext.Site.GetRegions())
                        {
                            JsonUserRegion pstReg = new JsonUserRegion(user, stReg);
                            foreach (UserRegion region in dataRegions)
                            {
                                if (region.RegionId == 0 || region.RegionId == stReg.Id)
                                {
                                    pstReg.Checked = true;
                                    break;
                                }
                            }
                            UserRegions.Add(pstReg);
                        }
                    }
                }
            }
        }
Esempio n. 7
0
 /// <summary>
 /// The File controller constructor.
 /// </summary>
 /// <param name="hostingEnvironment"></param>
 /// <param name="appContext"></param>
 public FileController(IHostingEnvironment hostingEnvironment, Services.WcmsAppContext appContext)
     : base(appContext)
 {
     //Console.WriteLine($"--- Services.FileController...");
     _hostingEnvironment = hostingEnvironment;
 }
Esempio n. 8
0
        /// <summary>
        /// Execute the authorization middleware logic.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="appContext"></param>
        /// <param name="hostEnvironment"></param>
        /// <param name="authorizationService"></param>
        /// <param name="loggerFactory"></param>
        /// <returns></returns>
        public async Task Invoke(HttpContext context,
                                 Services.WcmsAppContext appContext,
                                 IHostingEnvironment hostEnvironment,
                                 IAuthorizationService authorizationService,
                                 ILoggerFactory loggerFactory)
        {
            int       init        = 0;
            bool      adminPages  = false;
            bool      needUser    = false;
            string    virtualPath = null;
            IFileInfo flInf       = null;
            var       sw          = new Stopwatch(); sw.Start();

            // Checking....
            if (context == null)
            {
                throw new Exception("Authorization failed: Invalid context!!!");
            }
            else if (appContext == null)
            {
                throw new Exception("Authorization failed: Invalid app context!!!");
            }
            else if (hostEnvironment == null ||
                     hostEnvironment.ContentRootPath == null)
            {
                throw new Exception("Authorization failed: Invalid app env!!!");
            }
            else if (authorizationService == null)
            {
                throw new Exception("Authorization failed: Invalid authz!!!");
            }
            else if ((virtualPath = context?.Request?.Path.Value) == null)
            {
                throw new Exception("Authorization failed: Invalid path!!!");
            }
            // Init...
            ILogger log = loggerFactory?.CreateLogger(typeof(AuthorizationMiddleware).FullName);

            // Manage redirection from old vieetpartage site...
#if TRUE
            {
                string redirection = VepUrlRedirection.Migrate(
                    Microsoft.AspNetCore.Http.Extensions.UriHelper.GetDisplayUrl(context?.Request));
                if (redirection != null)
                {
                    context.Response.Redirect(redirection, false);
                    return;
                }
            }
#endif

            // Special cases where we don't need to initialize and check the access right...
            if (virtualPath == "/Plaintext")
            {
                // Performance test cases...
                await context.Response.WriteAsync("Ok\r\n");

                // Trace performance and exit...
                appContext?.AddPerfLog("AuthorizationMiddleware::Plaintext");
                return;
            }
#if DEBUG
            //else if (virtualPath.Contains("ng2") == true)
            //{
            //    // Allow common lib files...
            //    log?.LogInformation("Access granted to path \"{0}\": Lib files.", virtualPath);
            //    // Execute the next middleware...
            //    await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.1", "AuthorizationMiddleware::3.1", context);
            //    return;
            //}
#endif
            else if (virtualPath.StartsWith(CRoute.RouteStaticFile_Lib) == true)
            {
                // Allow common lib files...
                log?.LogInformation("Access granted to path \"{0}\": Lib files.", virtualPath);
                // Execute the next middleware...
                await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.1", "AuthorizationMiddleware::3.1", context);

                return;
            }
            else if (virtualPath.StartsWith($"{CRoute.RouteStaticFile_Admin}/assets") == true ||
                     virtualPath.StartsWith($"{CRoute.RouteStaticFile_Admin}/global") == true)
            {
                // Allow admin lib files...
                log?.LogInformation("Access granted to path \"{0}\": Admin Lib files.", virtualPath);
                // Execute the next middleware...
                await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.2", "AuthorizationMiddleware::3.2", context);

                return;
            }
            else if (virtualPath.StartsWith($"{CRoute.RouteStaticFile_Theme}") == true)
            {
                // Allow theme files...
                log?.LogInformation("Access granted to path \"{0}\": Theme files.", virtualPath);
                // Execute the next middleware...
                await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.3", "AuthorizationMiddleware::3.3", context);

                return;
            }
            else if (virtualPath.StartsWith("/jollyany") == true)
            {
                // Jollyany theme...
                context.Request.Path = new PathString(virtualPath.Replace("/jollyany", $"{CRoute.RouteStaticFile_Theme}jollyany"));
                // Allow theme files...
                log?.LogInformation("Access granted to path \"{0}\": Theme files.", virtualPath);
                // Execute the next middleware...
                await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.4", "AuthorizationMiddleware::3.4", context);

                return;
            }

            // Route overwritting cases...
            else if (virtualPath.StartsWith(CRoute.RouteStaticFile_Admin) == true)
            {
                // Admin area...
                if (virtualPath == CRoute.RouteStaticFile_Admin)
                {
                    // Redirect...
                    context.Response.Redirect($"{CRoute.RouteStaticFile_Admin}/");
                    appContext?.AddPerfLog("AuthorizationMiddleware::/admin");
                    return;
                }
                else if (virtualPath == $"{CRoute.RouteStaticFile_Admin}/")
                {
                    needUser             = true;
                    adminPages           = true;
                    virtualPath         += "index.html";
                    context.Request.Path = new PathString(virtualPath);
                }
                else if (virtualPath == $"{CRoute.RouteStaticFile_Admin}/index" ||
                         virtualPath == $"{CRoute.RouteStaticFile_Admin}/posts" ||
                         virtualPath == $"{CRoute.RouteStaticFile_Admin}/pages" ||
                         virtualPath == $"{CRoute.RouteStaticFile_Admin}/calendar" ||
                         virtualPath == $"{CRoute.RouteStaticFile_Admin}/users")
                {
                    needUser             = true;
                    adminPages           = true;
                    virtualPath         += ".html";
                    context.Request.Path = new PathString(virtualPath);
                }
                else
                {
                    // Admin page not allowsed, redirect to admin error page...
                    log?.LogInformation("\"{0}\" not allowed, redirect to admin error page.", virtualPath);
                    virtualPath          = $"{CRoute.RouteStaticFile_Admin}/error-404.html";
                    context.Request.Path = new PathString(virtualPath);
                    // Execute the next middleware...
                    await _NextMiddleWare(appContext, "AuthorizationMiddleware::3.1", "AuthorizationMiddleware::3.3", context);

                    return;
                }
            }

            // Initialize the application the site context
            // and check if the site can be view by the current user...
            if ((init = await appContext.InitSiteAsync(context, authorizationService)) != 1)
            {
                // We failed to initialize the context...
                if (init == 0)
                {
                    // The site cannot be found.
                    log?.LogError("Site {0} cannot be found!!!", context.Request.Host);
                    _StopChain(appContext, "AuthorizationMiddleware::40", context);
                    context.Response.StatusCode = 500;
                    await context.Response.WriteAsync($"Site {context.Request.Host} cannot be found!!!");
                }
                else if (init == 2)
                {
                    // The region cannot be found.
                    log?.LogInformation("Region {0} cannot be found!!!", appContext.RouteRegionName);
                    _StopChain(appContext, "AuthorizationMiddleware::41", context);
                    context.Response.StatusCode = 500;
                    await context.Response.WriteAsync($"Region {appContext.RouteRegionName} cannot be found!!!");
                }
                else if (init == 3)
                {
                    // The site module cannot be found.
                    log?.LogInformation("{0} module cannot be found!!!", appContext.RouteRegionName);
                    _StopChain(appContext, "AuthorizationMiddleware::44", context);
                    context.Response.StatusCode = 500;
                    await context.Response.WriteAsync($"{appContext.RouteRegionName} module cannot be found!!!");
                }
                else
                {
                    // Access is not granted, redirect to login page...
                    if (context.Request.Path.Value.ToLower() == CRoute.RouteAccountLogin.ToLower())
                    {
                        // Here something failed because we should not have a redirection on the login page.
                        log?.LogCritical("Internal ERROR: Init failed for {0}!!!", context.Request.Path);
                        _StopChain(appContext, "AuthorizationMiddleware::42", context);
                        context.Response.StatusCode = 500;
                        await context.Response.WriteAsync($"Internal ERROR: Init failed for {context.Request.Path}!!!");
                    }
                    else
                    {
                        log?.LogInformation("Access denied to path \"{0}\": Redirect to {CRoute.RouteAccountLogin}.", virtualPath);
                        _StopChain(appContext, "AuthorizationMiddleware::43", context);
                        context.Response.StatusCode = 401;
                        //context.Response.Redirect(CRoute.RouteAccountLogin);
                    }
                }
                // Exit...
                return;
            }
            // Check if we need a signed user...
            else if (needUser == true &&
                     appContext.SignInManager.IsSignedIn(context.User) == false)
            {
                // Here the page need a signed user, but no user is signed in,
                // so redirect to login page to authenticated the user...
                log?.LogInformation("Access denied to path \"{0}\": A signed user is needed.", virtualPath);
                if (adminPages == true)
                {
                    //virtualPath = virtualPath.Replace(".html", string.Empty);
                    //context.Request.Path = new PathString(virtualPath);
                    context.Response.Redirect(CRoute.RouteAccountLogin);
                }
                else
                {
                    context.Response.StatusCode = 401;
                }
                _StopChain(appContext, "AuthorizationMiddleware::6", context);
                return;
            }
            // Check access to the true file system...
            else if (((flInf = hostEnvironment?.WebRootFileProvider?.GetFileInfo(virtualPath))?.Exists ?? true) == true)
            {
                if (adminPages == true)
                {
                    // Allow admin pages...
                    log?.LogInformation("Access granted to path \"{0}\": Admin pages.", virtualPath);
                    await _NextMiddleWare(appContext, "AuthorizationMiddleware::7.1", "AuthorizationMiddleware::7.2", context);

                    return;
                }
                // Virtual path should not refer to the true file system...Denied the access...
                log?.LogInformation("Access denied to path \"{0}\": Access denied to the true FS.", virtualPath);
                context.Response.StatusCode = 403;
                _StopChain(appContext, "AuthorizationMiddleware::8", context);
                return;
            }
            else
            {
                log?.LogInformation("flInf.PhysicalPath=\"{0}\".", flInf?.PhysicalPath);

                // Create site path from the virtual path...
                string sitePath = $"/{appContext.Site.Id}{virtualPath}";
                // Is site path exist ?
                if (((flInf = hostEnvironment?.WebRootFileProvider?.GetFileInfo(sitePath))?.Exists ?? false) == true)
                {
                    // We have a site file, overwrite the path...
                    context.Request.Path = new PathString(sitePath);
                    // Check for root and libraries files (js libs, css, images and themes) of the site...
                    virtualPath = virtualPath.ToLower();
                    if (virtualPath == "/favicon.ico" ||
                        virtualPath == "/robots.txt" ||
                        virtualPath == "/podcast.xml" ||
                        virtualPath == "/logo.png" ||
                        virtualPath.StartsWith(CRoute.RouteStaticFile_Js) == true ||
                        virtualPath.StartsWith(CRoute.RouteStaticFile_Css) == true ||
                        virtualPath.StartsWith(CRoute.RouteStaticFile_Images) == true ||
                        virtualPath.StartsWith(CRoute.RouteStaticFile_Lib) == true ||
                        (virtualPath.StartsWith(CRoute.RouteStaticFile_Theme)) == true)
                    {
                        // Libraries are allowed...
                        log?.LogInformation("Access granted to path \"{0}\" (\"{1}\"): Site file public and common.", virtualPath, sitePath);
                        await _NextMiddleWare(appContext, "AuthorizationMiddleware::9.1", "AuthorizationMiddleware::9.2", context);

                        return;
                    }
                    // Check for post files...
                    else if (virtualPath.StartsWith(CRoute.RouteStaticFile_PostPub) == true)
                    {
                        // We have a post public file, allowed...
                        log?.LogInformation("Access granted to path \"{0}\": Access allowed to file from public post.", virtualPath);
                        await _NextMiddleWare(appContext, "AuthorizationMiddleware::10.1", "AuthorizationMiddleware::10.2", context);

                        return;
                    }
                    else if (virtualPath.StartsWith(CRoute.RouteStaticFile_Post) == true)
                    {
                        // We have a post private file, check access right...
                        int      postId  = 0;
                        Post     post    = null;
                        string[] folders = virtualPath.Split(_sep);
                        if (folders != null &&
                            folders.Length == 6 &&
                            int.TryParse(folders[4], out postId) == true &&
                            (post = await(new PostProvider(appContext))?.Get(postId)) != null)
                        {
                            // Here, the current user have read access to the post...
                            log?.LogInformation("Access granted to path \"{0}\": Access allowed.", virtualPath);
                            await _NextMiddleWare(appContext, "AuthorizationMiddleware::11.1", "AuthorizationMiddleware::11.2", context);

                            return;
                        }
                    }
                    // Other files are not allowed...
                    log?.LogInformation("Access denied to path \"{0}\": Not allowed.", virtualPath);
                    context.Response.StatusCode = 403;
                    _StopChain(appContext, "AuthorizationMiddleware::12", context);
                    return;
                }
                else
                {
                    // This is not site file, let other middleware process the request...
                    log?.LogInformation("Let other middleware process \"{0} - {1}\".", virtualPath, flInf?.PhysicalPath);
                    await _NextMiddleWare(appContext, "AuthorizationMiddleware::13.1", "AuthorizationMiddleware::13.2", context);

                    return;
                }
            }
        }
Esempio n. 9
0
        /// <summary>
        /// Get pages.
        /// </summary>
        /// <param name="appContext"></param>
        /// <param name="onlyInMenu"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        public static async Task <IEnumerable <Page> > Get(Services.WcmsAppContext appContext, bool onlyInMenu, int?parent = null)
        {
            // Checking...
            if ((appContext?.IsValid() ?? false) == false)
            {
                // Trace performance...
                appContext?.AddPerfLog("PageAuthorizationHandler::Get::Invalid context");
                return(null);
            }

            // User role and groups...
            string     userRole     = appContext.User?.HigherRole() ?? null;
            List <int> userGroupIds = appContext.User?.GroupsId();
            bool       haveGroup    = (userGroupIds != null && userGroupIds.Count() != 0);

            // Base query...
            var query = appContext.AppDbContext.Pages?.Where(p => p.SiteId == appContext.Site.Id);

            // Menu filter...
            if (onlyInMenu == true)
            {
                query = query?.Where(p => p.PositionInNavigation != 0);
            }
            // Parent filter...
            if (parent == null)
            {
                query = query?.Where(p => p.ParentId == null);
            }
            else if (parent != -1)
            {
                query = query?.Where(p => p.ParentId == parent.Value);
            }

            // Filtering based on the region...
            if (appContext.Site.HasRegions == true && (appContext.Region?.Id ?? -1) != -1)
            {
                query = query?
                        .Where(p => p.Region1 == 0 || p.Region1 == appContext.Region.Id ||
                               p.Region2 == 0 || p.Region2 == appContext.Region.Id ||
                               p.Region3 == 0 || p.Region3 == appContext.Region.Id ||
                               p.Region4 == 0 || p.Region4 == appContext.Region.Id ||
                               p.Region5 == 0 || p.Region5 == appContext.Region.Id ||
                               p.Region6 == 0 || p.Region6 == appContext.Region.Id ||
                               p.Region7 == 0 || p.Region7 == appContext.Region.Id ||
                               p.Region8 == 0 || p.Region8 == appContext.Region.Id ||
                               p.Region9 == 0 || p.Region9 == appContext.Region.Id ||
                               p.Region10 == 0 || p.Region10 == appContext.Region.Id);
            }

            // Authorization filtering...
            // Administrator and publicator have read rights on all pages of the same groups...
            if ((userRole == ClaimValueRole.Administrator || userRole == ClaimValueRole.Publicator) &&
                haveGroup == true)
            {
                query = query?
                        .Where(p => (p.Private == false ||
                                     (p.Group1 != -1 && (appContext.User.Group1 == p.Group1 || appContext.User.Group2 == p.Group1 || appContext.User.Group3 == p.Group1 || appContext.User.Group4 == p.Group1 || appContext.User.Group5 == p.Group1 || appContext.User.Group6 == p.Group1 || appContext.User.Group7 == p.Group1 || appContext.User.Group8 == p.Group1 || appContext.User.Group9 == p.Group1 || appContext.User.Group10 == p.Group1)) ||
                                     (p.Group2 != -1 && (appContext.User.Group1 == p.Group2 || appContext.User.Group2 == p.Group2 || appContext.User.Group3 == p.Group2 || appContext.User.Group4 == p.Group2 || appContext.User.Group5 == p.Group2 || appContext.User.Group6 == p.Group2 || appContext.User.Group7 == p.Group2 || appContext.User.Group8 == p.Group2 || appContext.User.Group9 == p.Group2 || appContext.User.Group10 == p.Group2)) ||
                                     (p.Group3 != -1 && (appContext.User.Group1 == p.Group3 || appContext.User.Group2 == p.Group3 || appContext.User.Group3 == p.Group3 || appContext.User.Group4 == p.Group3 || appContext.User.Group5 == p.Group3 || appContext.User.Group6 == p.Group3 || appContext.User.Group7 == p.Group3 || appContext.User.Group8 == p.Group3 || appContext.User.Group9 == p.Group3 || appContext.User.Group10 == p.Group3)) ||
                                     (p.Group4 != -1 && (appContext.User.Group1 == p.Group4 || appContext.User.Group2 == p.Group4 || appContext.User.Group3 == p.Group4 || appContext.User.Group4 == p.Group4 || appContext.User.Group5 == p.Group4 || appContext.User.Group6 == p.Group4 || appContext.User.Group7 == p.Group4 || appContext.User.Group8 == p.Group4 || appContext.User.Group9 == p.Group4 || appContext.User.Group10 == p.Group4)) ||
                                     (p.Group5 != -1 && (appContext.User.Group1 == p.Group5 || appContext.User.Group2 == p.Group5 || appContext.User.Group3 == p.Group5 || appContext.User.Group4 == p.Group5 || appContext.User.Group5 == p.Group5 || appContext.User.Group6 == p.Group5 || appContext.User.Group7 == p.Group5 || appContext.User.Group8 == p.Group5 || appContext.User.Group9 == p.Group5 || appContext.User.Group10 == p.Group5)) ||
                                     (p.Group6 != -1 && (appContext.User.Group1 == p.Group6 || appContext.User.Group2 == p.Group6 || appContext.User.Group3 == p.Group6 || appContext.User.Group4 == p.Group6 || appContext.User.Group5 == p.Group6 || appContext.User.Group6 == p.Group6 || appContext.User.Group7 == p.Group6 || appContext.User.Group8 == p.Group6 || appContext.User.Group9 == p.Group6 || appContext.User.Group10 == p.Group6)) ||
                                     (p.Group7 != -1 && (appContext.User.Group1 == p.Group7 || appContext.User.Group2 == p.Group7 || appContext.User.Group3 == p.Group7 || appContext.User.Group4 == p.Group7 || appContext.User.Group5 == p.Group7 || appContext.User.Group6 == p.Group7 || appContext.User.Group7 == p.Group7 || appContext.User.Group8 == p.Group7 || appContext.User.Group9 == p.Group7 || appContext.User.Group10 == p.Group7)) ||
                                     (p.Group8 != -1 && (appContext.User.Group1 == p.Group8 || appContext.User.Group2 == p.Group8 || appContext.User.Group3 == p.Group8 || appContext.User.Group4 == p.Group8 || appContext.User.Group5 == p.Group8 || appContext.User.Group6 == p.Group8 || appContext.User.Group7 == p.Group8 || appContext.User.Group8 == p.Group8 || appContext.User.Group9 == p.Group8 || appContext.User.Group10 == p.Group8)) ||
                                     (p.Group9 != -1 && (appContext.User.Group1 == p.Group9 || appContext.User.Group2 == p.Group9 || appContext.User.Group3 == p.Group9 || appContext.User.Group4 == p.Group9 || appContext.User.Group5 == p.Group9 || appContext.User.Group6 == p.Group9 || appContext.User.Group7 == p.Group9 || appContext.User.Group8 == p.Group9 || appContext.User.Group9 == p.Group9 || appContext.User.Group10 == p.Group9)) ||
                                     (p.Group10 != -1 && (appContext.User.Group1 == p.Group10 || appContext.User.Group2 == p.Group10 || appContext.User.Group3 == p.Group10 || appContext.User.Group4 == p.Group10 || appContext.User.Group5 == p.Group10 || appContext.User.Group6 == p.Group10 || appContext.User.Group7 == p.Group10 || appContext.User.Group8 == p.Group10 || appContext.User.Group9 == p.Group10 || appContext.User.Group10 == p.Group10))));
            }
            // Contributeur and reader can only read published page of the same groups...
            else if ((userRole == ClaimValueRole.Contributor || userRole == ClaimValueRole.Reader) &&
                     haveGroup == true)
            {
                query = query?
                        .Where(p => p.State == State.Valided &&
                               (p.Private == false ||
                                (p.Group1 != -1 && (appContext.User.Group1 == p.Group1 || appContext.User.Group2 == p.Group1 || appContext.User.Group3 == p.Group1 || appContext.User.Group4 == p.Group1 || appContext.User.Group5 == p.Group1 || appContext.User.Group6 == p.Group1 || appContext.User.Group7 == p.Group1 || appContext.User.Group8 == p.Group1 || appContext.User.Group9 == p.Group1 || appContext.User.Group10 == p.Group1)) ||
                                (p.Group2 != -1 && (appContext.User.Group1 == p.Group2 || appContext.User.Group2 == p.Group2 || appContext.User.Group3 == p.Group2 || appContext.User.Group4 == p.Group2 || appContext.User.Group5 == p.Group2 || appContext.User.Group6 == p.Group2 || appContext.User.Group7 == p.Group2 || appContext.User.Group8 == p.Group2 || appContext.User.Group9 == p.Group2 || appContext.User.Group10 == p.Group2)) ||
                                (p.Group3 != -1 && (appContext.User.Group1 == p.Group3 || appContext.User.Group2 == p.Group3 || appContext.User.Group3 == p.Group3 || appContext.User.Group4 == p.Group3 || appContext.User.Group5 == p.Group3 || appContext.User.Group6 == p.Group3 || appContext.User.Group7 == p.Group3 || appContext.User.Group8 == p.Group3 || appContext.User.Group9 == p.Group3 || appContext.User.Group10 == p.Group3)) ||
                                (p.Group4 != -1 && (appContext.User.Group1 == p.Group4 || appContext.User.Group2 == p.Group4 || appContext.User.Group3 == p.Group4 || appContext.User.Group4 == p.Group4 || appContext.User.Group5 == p.Group4 || appContext.User.Group6 == p.Group4 || appContext.User.Group7 == p.Group4 || appContext.User.Group8 == p.Group4 || appContext.User.Group9 == p.Group4 || appContext.User.Group10 == p.Group4)) ||
                                (p.Group5 != -1 && (appContext.User.Group1 == p.Group5 || appContext.User.Group2 == p.Group5 || appContext.User.Group3 == p.Group5 || appContext.User.Group4 == p.Group5 || appContext.User.Group5 == p.Group5 || appContext.User.Group6 == p.Group5 || appContext.User.Group7 == p.Group5 || appContext.User.Group8 == p.Group5 || appContext.User.Group9 == p.Group5 || appContext.User.Group10 == p.Group5)) ||
                                (p.Group6 != -1 && (appContext.User.Group1 == p.Group6 || appContext.User.Group2 == p.Group6 || appContext.User.Group3 == p.Group6 || appContext.User.Group4 == p.Group6 || appContext.User.Group5 == p.Group6 || appContext.User.Group6 == p.Group6 || appContext.User.Group7 == p.Group6 || appContext.User.Group8 == p.Group6 || appContext.User.Group9 == p.Group6 || appContext.User.Group10 == p.Group6)) ||
                                (p.Group7 != -1 && (appContext.User.Group1 == p.Group7 || appContext.User.Group2 == p.Group7 || appContext.User.Group3 == p.Group7 || appContext.User.Group4 == p.Group7 || appContext.User.Group5 == p.Group7 || appContext.User.Group6 == p.Group7 || appContext.User.Group7 == p.Group7 || appContext.User.Group8 == p.Group7 || appContext.User.Group9 == p.Group7 || appContext.User.Group10 == p.Group7)) ||
                                (p.Group8 != -1 && (appContext.User.Group1 == p.Group8 || appContext.User.Group2 == p.Group8 || appContext.User.Group3 == p.Group8 || appContext.User.Group4 == p.Group8 || appContext.User.Group5 == p.Group8 || appContext.User.Group6 == p.Group8 || appContext.User.Group7 == p.Group8 || appContext.User.Group8 == p.Group8 || appContext.User.Group9 == p.Group8 || appContext.User.Group10 == p.Group8)) ||
                                (p.Group9 != -1 && (appContext.User.Group1 == p.Group9 || appContext.User.Group2 == p.Group9 || appContext.User.Group3 == p.Group9 || appContext.User.Group4 == p.Group9 || appContext.User.Group5 == p.Group9 || appContext.User.Group6 == p.Group9 || appContext.User.Group7 == p.Group9 || appContext.User.Group8 == p.Group9 || appContext.User.Group9 == p.Group9 || appContext.User.Group10 == p.Group9)) ||
                                (p.Group10 != -1 && (appContext.User.Group1 == p.Group10 || appContext.User.Group2 == p.Group10 || appContext.User.Group3 == p.Group10 || appContext.User.Group4 == p.Group10 || appContext.User.Group5 == p.Group10 || appContext.User.Group6 == p.Group10 || appContext.User.Group7 == p.Group10 || appContext.User.Group8 == p.Group10 || appContext.User.Group9 == p.Group10 || appContext.User.Group10 == p.Group10))));
            }
            // Have role but no group...
            else if (userRole == ClaimValueRole.Administrator || userRole == ClaimValueRole.Publicator)
            {
                query = query?.Where(p => p.Private == false);
            }
            else if (userRole == ClaimValueRole.Contributor || userRole == ClaimValueRole.Reader)
            {
                query = query?.Where(p => p.State == State.Valided && p.Private == false);
            }
            // No role and no group...
            else
            {
                query = query?.Where(p => p.State == State.Valided && p.Private == false);
            }

            if (query == null)
            {
                // Trace performance...
                appContext?.AddPerfLog("PageAuthorizationHandler::Get::Query build failed");
                return(null);
            }
            // Trace performance...
            appContext?.AddPerfLog("PageAuthorizationHandler::Get::Query built");
            List <Page> pages = await query
                                .OrderBy(p => p.PositionInNavigation)
#if !PERF_ISSUE
                                //TODO: Add a way to customize fields we want to retrieve with the request...
#if !DENORMALIZE
                                .Include(p => p.PageGroups)
                                .Include(p => p.PageRegions)
                                .Include(p => p.PageCategorys)
                                .Include(p => p.PageTags)
#endif
                                .Include(p => p.PageClaims)
#endif
                                .AsNoTracking()
                                .ToListAsync();

            // Trace performance...
            appContext?.AddPerfLog("PageAuthorizationHandler::Get::Query executed");
            return(pages);
        }
Esempio n. 10
0
 /// <summary>
 /// The Page api controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public PageApiController(Services.WcmsAppContext appContext)
     : base(appContext)
 {
     provider = new PageProvider(AppContext);
 }
Esempio n. 11
0
        /// <summary>
        /// Get users.
        /// </summary>
        /// <param name="appContext"></param>
        /// <param name="filters"></param>
        /// <param name="skip"></param>
        /// <param name="take"></param>
        /// <param name="allFields"></param>
        /// <returns></returns>
        public static async Task <IEnumerable <ApplicationUser> > Get(Services.WcmsAppContext appContext, Dictionary <string, object> filters, int skip, int take, bool allFields)
        {
            DataSorting orderBy = DataSorting.Email;

            // Checking...
            if (skip < 0)
            {
                skip = 0;
            }
            else if (take <= 0)
            {
                take = 20;
            }
            else if (take > 200)
            {
                take = 200;
            }
            // Build the query...
            var query = _GetQuery(appContext, filters, ref orderBy);

            if (query == null)
            {
                return(null);
            }
            // Sorting...
            if (orderBy == DataSorting.UserName)
            {
                query = query.OrderBy(p => p.UserName);
            }
            else if (orderBy == DataSorting.Email)
            {
                query = query.OrderBy(p => p.Email);
            }
            // Fields included...
            if (allFields == true)
            {
                query = query
                        .Include(p => p.Claims)
                        .Select(p => new ApplicationUser
                {
                    AccessFailedCount = p.AccessFailedCount,
                    Email             = p.Email,
                    EmailConfirmed    = p.EmailConfirmed,
                    Id = p.Id,
                    //LockoutEnabled = p.LockoutEnabled,
                    LockoutEnd = p.LockoutEnd,
                    //PhoneNumber = p.PhoneNumber,
                    PhoneNumberConfirmed = p.PhoneNumberConfirmed,
                    UserName             = p.UserName,
                });
                //.Include(p => p.Creator); //TODO: Only need for Unit test.
            }
            // Trace performance...
            appContext?.AddPerfLog("UserAuthorizationHandler::Get::Query built");
            // Execute the query...
            IEnumerable <ApplicationUser> items = await query
                                                  .Skip(skip *take).Take(take)
                                                  .ToListAsync();

            // Trace performance...
            appContext?.AddPerfLog("UserAuthorizationHandler::Get::Query executed");
            // Exit...
            return(items);
        }
Esempio n. 12
0
 /// <summary>
 /// The Base post controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 /// <param name="emailSender"></param>
 public PostController(Services.WcmsAppContext appContext, IEmailSender emailSender)
     : base(appContext)
 {
     _emailSender = emailSender;
 }
Esempio n. 13
0
 /// <summary>
 /// The Post api controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public PostApiController(IHostingEnvironment environment,
                          Services.WcmsAppContext appContext, IEmailSender emailSender)
     : base(appContext)
 {
     _emailSender = emailSender;
 }
Esempio n. 14
0
        public JsonPost(Services.WcmsAppContext AppContext, Post post = null, bool forEdition = false)
        {
            ICollection<PostGroup> postGroups = null;
            ICollection<PostRegion> postRegions = null;
            ICollection<PostCategory> postCategorys = null;
            ICollection<PostTag> postTags = null;

            // Set...
            if (post != null)
            {
                Id = post.Id;
                Title = post.Title;
                State = post.State;
                Private = post.Private;
                Cover = post.GetCoverUrl();
                CoverCrop = post.GetCoverUrl().Replace("cover", "cover.crop");
                Text = post.Text;
                CreatorId = post.CreatorId;
                CreatorName = post.Creator?.UserName ?? "???";
                CreationDate = post.CreationDate;
                ModifiedDate = post.ModifiedDate;
                ValidationDate = post.ValidationDate;
                // Age...
                {
                    TimeSpan ts = (ModifiedDate != null)
                        ? DateTime.Now.Subtract(ModifiedDate.Value)
                        : DateTime.Now.Subtract(CreationDate);
                    if (ts.TotalDays < 30)
                    {
                        Age = Convert.ToInt32(ts.TotalDays);
                        AgeUnit = (Age <= 1) ? "jour" : "jours";
                    }
                    else if (ts.TotalDays < 365)
                    {
                        Age = Convert.ToInt32(ts.TotalDays) / 30;
                        AgeUnit = "mois";
                    }
                    else
                    {
                        Age = Convert.ToInt32(ts.TotalDays) / 365;
                        AgeUnit = "ans";
                    }
                }
                Highlight = post.Highlight;
                StartDate = post.StartDate;
                StartDateString = post.StartDate?.ToString("dd/MM/yyyy HH:mm");
                EndDate = post.EndDate;
                EndDateString = post.EndDate?.ToString("dd/MM/yyyy HH:mm");
#               if !DENORMALIZE
                if ((postGroups = post.PostGroups)) != null)
#               else
                if ((postGroups = post.PostGroups(AppContext)) != null)
#               endif
                {
                    PostGroups = new List<JsonPostGroup>();
                    if (forEdition == false)
                    {
                        foreach (PostGroup group in postGroups)
                        {
                            PostGroups.Add(new JsonPostGroup(group));
                        }
                    }
                    else
                    {
                        ICollection<SiteClaim> userGroups = AppContext.Site.GetGroups(AppContext?.User?.GroupsId());
                        if (userGroups != null)
                        {
                            foreach (SiteClaim stGrp in userGroups)
                            {
                                JsonPostGroup pstGrp = new JsonPostGroup(post, stGrp);
                                foreach (PostGroup group in postGroups)
                                {
                                    if (group.GroupId == stGrp.Id)
                                    {
                                        pstGrp.Checked = true;
                                        break;
                                    }
                                }
                                PostGroups.Add(pstGrp);
                            }
                        }
                    }
                }
#               if !DENORMALIZE
                if ((postRegions = post.PostRegions) != null)
Esempio n. 15
0
 /// <summary>
 /// The Home controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public HomeController(Services.WcmsAppContext appContext)
     : base(appContext)
 {
     //Console.WriteLine($"--- Services.HomeController...");
 }
Esempio n. 16
0
        /// <summary>
        /// Get user query.
        /// </summary>
        /// <param name="appContext"></param>
        /// <param name="filters"></param>
        /// <param name="orderBy"></param>
        /// <returns></returns>
        private static IQueryable <ApplicationUser> _GetQuery(Services.WcmsAppContext appContext, Dictionary <string, object> filters, ref DataSorting orderBy)
        {
            ApplicationUser userGroups = null;

            // Checking...
            if ((appContext?.IsValid() ?? false) == false)
            {
                return(null);
            }
            // Init...
            orderBy = DataSorting.Validation;

            // User role and groups...
            string     userRole     = appContext.User?.HigherRole() ?? null;
            List <int> userGroupIds = appContext.User?.GroupsId();

            if (userGroupIds != null && userGroupIds.Count > 0)
            {
                userGroups         = new ApplicationUser();
                userGroups.Group1  = appContext.User.Group1;
                userGroups.Group2  = appContext.User.Group2;
                userGroups.Group3  = appContext.User.Group3;
                userGroups.Group4  = appContext.User.Group4;
                userGroups.Group5  = appContext.User.Group5;
                userGroups.Group6  = appContext.User.Group6;
                userGroups.Group7  = appContext.User.Group7;
                userGroups.Group8  = appContext.User.Group8;
                userGroups.Group9  = appContext.User.Group9;
                userGroups.Group10 = appContext.User.Group10;
            }

            // Get filter to apply on the user table...
            string title         = null;
            bool   filterOngroup = false;

            if (filters != null)
            {
                foreach (KeyValuePair <string, object> filter in filters)
                {
                    if (filter.Key != null && filter.Value != null)
                    {
                        if (filter.Key == QueryFilter.Title &&
                            string.IsNullOrWhiteSpace((string)filter.Value) == false)
                        {
                            title = (string)filter.Value;
                        }
                        else if (filter.Key == QueryFilter.Group)
                        {
                            filterOngroup = true;
                            if (userGroupIds != null && userGroupIds.Count > 0)
                            {
                                if (userGroupIds.Contains((int)filter.Value) == true)
                                {
                                    userGroups.Group1  = (int)filter.Value;
                                    userGroups.Group2  = -1;
                                    userGroups.Group3  = -1;
                                    userGroups.Group4  = -1;
                                    userGroups.Group5  = -1;
                                    userGroups.Group6  = -1;
                                    userGroups.Group7  = -1;
                                    userGroups.Group8  = -1;
                                    userGroups.Group9  = -1;
                                    userGroups.Group10 = -1;
                                }
                                else
                                {
                                    // The asked group is not part of the user groups...so return an empty list...
                                    return(null);
                                }
                            }
                            else
                            {
                                // User is not part of any group...so return an empty list...
                                return(null);
                            }
                        }

                        /*else if (filter.Key == QueryFilter.UserEnabled)
                         * {
                         * }
                         * else if (filter.Key == QueryFilter.UserLocked)
                         * {
                         * }
                         * else if (filter.Key == QueryFilter.EmailConfirmed)
                         * {
                         * }*/
                    }
                }
            }

            // Base query...
            var query = appContext.AppDbContext.Users?.Where(u => u.SiteId == appContext.Site.Id);

            // Title filter...
            if (title != null)
            {
                query = query?.Where(u => u.UserName.Contains(title) == true ||
                                     u.Email.Contains(title) == true);
            }

            // Filtering based on the region...
            if (appContext.Site.HasRegions == true && (appContext.Region?.Id ?? -1) != -1)
            {
                query = query?
                        .Where(u => u.Region1 == 0 || u.Region1 == appContext.Region.Id ||
                               u.Region2 == 0 || u.Region2 == appContext.Region.Id ||
                               u.Region3 == 0 || u.Region3 == appContext.Region.Id ||
                               u.Region4 == 0 || u.Region4 == appContext.Region.Id ||
                               u.Region5 == 0 || u.Region5 == appContext.Region.Id ||
                               u.Region6 == 0 || u.Region6 == appContext.Region.Id ||
                               u.Region7 == 0 || u.Region7 == appContext.Region.Id ||
                               u.Region8 == 0 || u.Region8 == appContext.Region.Id ||
                               u.Region9 == 0 || u.Region9 == appContext.Region.Id ||
                               u.Region10 == 0 || u.Region10 == appContext.Region.Id);
            }

            // Administrator have read rights on all users of the same groups...
            if ((userRole == ClaimValueRole.Administrator) && userGroups != null)
            {
                query = query?
                        .Where(p => (p.Group1 != -1 && (userGroups.Group1 == p.Group1 || userGroups.Group2 == p.Group1 || userGroups.Group3 == p.Group1 || userGroups.Group4 == p.Group1 || userGroups.Group5 == p.Group1 || userGroups.Group6 == p.Group1 || userGroups.Group7 == p.Group1 || userGroups.Group8 == p.Group1 || userGroups.Group9 == p.Group1 || userGroups.Group10 == p.Group1)) ||
                               (p.Group2 != -1 && (userGroups.Group1 == p.Group2 || userGroups.Group2 == p.Group2 || userGroups.Group3 == p.Group2 || userGroups.Group4 == p.Group2 || userGroups.Group5 == p.Group2 || userGroups.Group6 == p.Group2 || userGroups.Group7 == p.Group2 || userGroups.Group8 == p.Group2 || userGroups.Group9 == p.Group2 || userGroups.Group10 == p.Group2)) ||
                               (p.Group3 != -1 && (userGroups.Group1 == p.Group3 || userGroups.Group2 == p.Group3 || userGroups.Group3 == p.Group3 || userGroups.Group4 == p.Group3 || userGroups.Group5 == p.Group3 || userGroups.Group6 == p.Group3 || userGroups.Group7 == p.Group3 || userGroups.Group8 == p.Group3 || userGroups.Group9 == p.Group3 || userGroups.Group10 == p.Group3)) ||
                               (p.Group4 != -1 && (userGroups.Group1 == p.Group4 || userGroups.Group2 == p.Group4 || userGroups.Group3 == p.Group4 || userGroups.Group4 == p.Group4 || userGroups.Group5 == p.Group4 || userGroups.Group6 == p.Group4 || userGroups.Group7 == p.Group4 || userGroups.Group8 == p.Group4 || userGroups.Group9 == p.Group4 || userGroups.Group10 == p.Group4)) ||
                               (p.Group5 != -1 && (userGroups.Group1 == p.Group5 || userGroups.Group2 == p.Group5 || userGroups.Group3 == p.Group5 || userGroups.Group4 == p.Group5 || userGroups.Group5 == p.Group5 || userGroups.Group6 == p.Group5 || userGroups.Group7 == p.Group5 || userGroups.Group8 == p.Group5 || userGroups.Group9 == p.Group5 || userGroups.Group10 == p.Group5)) ||
                               (p.Group6 != -1 && (userGroups.Group1 == p.Group6 || userGroups.Group2 == p.Group6 || userGroups.Group3 == p.Group6 || userGroups.Group4 == p.Group6 || userGroups.Group5 == p.Group6 || userGroups.Group6 == p.Group6 || userGroups.Group7 == p.Group6 || userGroups.Group8 == p.Group6 || userGroups.Group9 == p.Group6 || userGroups.Group10 == p.Group6)) ||
                               (p.Group7 != -1 && (userGroups.Group1 == p.Group7 || userGroups.Group2 == p.Group7 || userGroups.Group3 == p.Group7 || userGroups.Group4 == p.Group7 || userGroups.Group5 == p.Group7 || userGroups.Group6 == p.Group7 || userGroups.Group7 == p.Group7 || userGroups.Group8 == p.Group7 || userGroups.Group9 == p.Group7 || userGroups.Group10 == p.Group7)) ||
                               (p.Group8 != -1 && (userGroups.Group1 == p.Group8 || userGroups.Group2 == p.Group8 || userGroups.Group3 == p.Group8 || userGroups.Group4 == p.Group8 || userGroups.Group5 == p.Group8 || userGroups.Group6 == p.Group8 || userGroups.Group7 == p.Group8 || userGroups.Group8 == p.Group8 || userGroups.Group9 == p.Group8 || userGroups.Group10 == p.Group8)) ||
                               (p.Group9 != -1 && (userGroups.Group1 == p.Group9 || userGroups.Group2 == p.Group9 || userGroups.Group3 == p.Group9 || userGroups.Group4 == p.Group9 || userGroups.Group5 == p.Group9 || userGroups.Group6 == p.Group9 || userGroups.Group7 == p.Group9 || userGroups.Group8 == p.Group9 || userGroups.Group9 == p.Group9 || userGroups.Group10 == p.Group9)) ||
                               (p.Group10 != -1 && (userGroups.Group1 == p.Group10 || userGroups.Group2 == p.Group10 || userGroups.Group3 == p.Group10 || userGroups.Group4 == p.Group10 || userGroups.Group5 == p.Group10 || userGroups.Group6 == p.Group10 || userGroups.Group7 == p.Group10 || userGroups.Group8 == p.Group10 || userGroups.Group9 == p.Group10 || userGroups.Group10 == p.Group10)));
            }
            // Have role but no group...
            else if (userRole == ClaimValueRole.Administrator)
            {
                // Can only see user without group...
                query = query?
                        .Where(p => p.Group1 == -1 &&
                               p.Group2 == -1 &&
                               p.Group3 == -1 &&
                               p.Group4 == -1 &&
                               p.Group5 == -1 &&
                               p.Group6 == -1 &&
                               p.Group7 == -1 &&
                               p.Group8 == -1 &&
                               p.Group9 == -1 &&
                               p.Group10 == -1);
            }
            // No role and no group...
            else
            {
                return(null);
            }

            return(query);
        }
Esempio n. 17
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public SiteApiController(Services.WcmsAppContext appContext)
     : base(appContext)
 {
     provider = new SiteProvider(appContext);
 }
Esempio n. 18
0
 /// <summary>
 /// The User api controller constructor.
 /// </summary>
 /// <param name="appContext"></param>
 public UserApiController(IHostingEnvironment environment, Services.WcmsAppContext appContext)
     : base(appContext)
 {
 }