public BaseRestApiInterface AddBlogPosts([FromBody] BlogPost newblogPost)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            newblogPost.CreatedDate  = DateTime.Now;
            newblogPost.CreatedBy    = user.UserId;
            newblogPost.ModifiedBy   = user.UserId;
            newblogPost.ModifiedDate = DateTime.Now;
            newblogPost.Status       = (int)PostStatus.Draft;
            result.process((ctx) =>
            {
                var oldblogPost = ctx.BlogPosts.Where(a => a.Title == newblogPost.Title).SingleOrDefault();
                if (oldblogPost == null)
                {
                    var newBlog = ctx.BlogPosts.Add(newblogPost);
                    ctx.SaveChanges();
                    return(new ArrayList()
                    {
                        newBlog
                    });
                }
                else
                {
                    throw new BlogException("blogpostExists", new string[] { newblogPost.Title });
                }
            });

            return(result);
        }
        public BaseRestApiInterface PublicToReady(int blogId)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var blogPost = ctx.BlogPosts.Where(b => b.BlogId == blogId).SingleOrDefault();

                if (blogPost == null)
                {
                    throw new BlogException("blogpostnotExists", new string[] { blogPost.Title });
                }
                else
                {
                    blogPost.PublishToDate = DateTime.Now;
                    blogPost.Status        = (int)PostStatus.ReadToPublish;
                    blogPost.ModifiedDate  = DateTime.Now;
                    blogPost.ModifiedBy    = user.UserName;
                    ctx.SaveChanges();
                }
            });

            return(result);
        }
        public BaseRestApiInterface EditBlogPosts([FromBody] BlogPost blogPost)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var oldblogPost = ctx.BlogPosts.Where(a => a.Title == blogPost.Title).SingleOrDefault();

                if (oldblogPost == null)
                {
                    throw new BlogException("blogpostnotExists", new string[] { blogPost.Title });
                }
                else
                {
                    oldblogPost.Content      = blogPost.Content;
                    oldblogPost.ImageUrl     = blogPost.ImageUrl;
                    oldblogPost.ModifiedBy   = user.UserName;
                    oldblogPost.ModifiedDate = DateTime.Now;
                    ctx.SaveChanges();
                }
            });

            return(result);
        }
Beispiel #4
0
        public BaseRestApiInterface updateUser([FromBody] User updateUser)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }

            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var oldUser = ctx.User.Where(u => u.UserId == updateUser.UserId).SingleOrDefault();
                if (oldUser != null)
                {
                    oldUser.UserEmail = updateUser.UserEmail;
                    oldUser.UserName  = updateUser.UserName;
                    oldUser.UserRole  = updateUser.UserRole;
                    ctx.SaveChanges();
                }
                else
                {
                    throw new BlogException("userNotFound", new string[] { updateUser.UserId });
                }
            });
            return(result);
        }
Beispiel #5
0
        public BaseRestApiInterface addUser([FromBody] User newUser)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }

            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var oldUser = ctx.User.Where(u => u.UserId == newUser.UserId).SingleOrDefault();
                if (oldUser == null)
                {
                    var nu = ctx.User.Add(newUser);
                    ctx.SaveChanges();
                    return(new ArrayList()
                    {
                        nu
                    });
                }
                else
                {
                    throw new BlogException("userExists", new string[] { newUser.UserId });
                }
            });
            return(result);
        }
        public BaseRestApiInterface AppliedStatus(int blogId, PostStatus pt)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var blogPost = ctx.BlogPosts.Find(new int[] { blogId });

                if (blogPost == null)
                {
                    throw new BlogException("blogpostnotExists", new string[] { blogPost.Title });
                }
                else
                {
                    switch (pt)
                    {
                    case PostStatus.Draft:
                        blogPost.Status = (int)PostStatus.Draft;
                        break;

                    case PostStatus.ReadToPublish:
                        blogPost.Status = (int)PostStatus.ReadToPublish;
                        break;

                    case PostStatus.Reject:
                        blogPost.Status = (int)PostStatus.Reject;
                        break;

                    case PostStatus.Published:
                        blogPost.Status = (int)PostStatus.Published;
                        break;

                    case PostStatus.Archived:
                        blogPost.Status = (int)PostStatus.Archived;
                        break;

                    default:
                        break;
                    }

                    blogPost.ModifiedDate = DateTime.Now;
                    blogPost.ModifiedBy   = user.UserName;
                    ctx.SaveChanges();
                }
            });

            return(result);
        }
        public BaseRestApiInterface getLoggedOnUser()
        {
            //deprecated with JWT flow
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) => {
                string userID = this.RequestContext.Principal.Identity.Name;
                var query     = from u in ctx.User where u.UserId == userID select u;
                if (query.Count() == 0)
                {
                    throw new BlogException("userNotFound", new string[] { "" });
                }
                return(query.First());
            });
            return(result);
        }
        public BaseRestApiInterface GetBlogPostById(int id)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                return((from blog in ctx.BlogPosts where blog.BlogId.Equals(id) select blog).FirstOrDefault());
            });

            return(result);
        }
        public BaseRestApiInterface GetBlogPosts()
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                return(ctx.BlogPosts.OrderBy((item) => item.BlogId).ToList());
            });

            return(result);
        }
        public BaseRestApiInterface validateLogin([FromBody] JWTAuthenticationToken oldTokens)
        {
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) => {
                var token = jwtAuth.ValidateToken(oldTokens.Token);
                if (token == null)
                {
                    return(jwtAuth.GetNewAccessTokenFromRefreshToken(oldTokens.RefreshToken, ctx));
                }
                else
                {
                    oldTokens.User = jwtAuth.GetUserFromAccessToken(token, true);
                }
                return(oldTokens);
            });
            return(result);
        }
Beispiel #11
0
        public BaseRestApiInterface getAllUsers()
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }

            string s = this.RequestContext.Principal.Identity.Name;

            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                return(ctx.User.OrderBy((item) => item.UserId).ToList());
            });
            return(result);
        }
Beispiel #12
0
        public BaseRestApiInterface getUsers(string id)
        {
            User user = jwtAuth.GetUserFromAccessToken(jwtAuth.ValidateToken(Request.Headers.Authorization.Scheme), false);

            if (user == null)
            {
                throw new BlogException("userNotAccessRight", new String[] { user.UserId });
            }

            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) =>
            {
                var query = from u in ctx.User
                            where (u.UserId == id)
                            select u;
                return(query.OrderBy((item) => item.UserId).ToList());
            });
            return(result);
        }
        public BaseRestApiInterface doLogin([FromBody] User oldUser)
        {
            BaseRestApiResult result = new BaseRestApiResult();

            result.process((ctx) => {
                var query = (from u in ctx.User where u.UserId.ToLower() == oldUser.UserId.ToLower() && u.Password == oldUser.Password select u).ToList();
                if (query.Count == 0)
                {
                    throw new BlogException("userNotFound", new string[] { oldUser.UserId });
                }
                else
                {
                    User u                        = query.First();
                    string token                  = jwtAuth.CreateAccessToken(u.UserName, u.UserId, u.UserRole);
                    string refresh_token          = jwtAuth.CreateRefreshToken(u.UserId);
                    JWTAuthenticationToken tokens = new JWTAuthenticationToken();
                    tokens.Token                  = token;
                    tokens.RefreshToken           = refresh_token;
                    tokens.User                   = u;
                    return(tokens);
                }
            });
            return(result);
        }