public async Task <IActionResult> CreateNewFoler(string id, string token, [FromBody] Folder folder)
        {
            try
            {
                var tokenManagerService = new TokenManagerService();
                if (tokenManagerService.ValidateToken(token, out userName, out hashKey))
                {
                    User user = await new UserService().GetUser(userName, hashKey);

                    var parentFolder = await new FolderService().GetFolder(id);

                    folder.FolderDate     = DateTime.Now;
                    folder.UserId         = parentFolder.UserId;
                    folder.ParentFolderId = id;

                    await new FolderService().CreateFolder(folder);
                    return(Ok());
                }

                return(Unauthorized());
            }
            catch
            {
                return(BadRequest());
            }
        }
Beispiel #2
0
 public BookServiceController(BookManagerService bookManagerService, S3FileProcessorService s3FileProcessorService, TokenManagerService tokenManagerService, ILogger <BookServiceController> logger)
 {
     _bookManagerService     = bookManagerService;
     _logger                 = logger;
     _s3FileProcessorService = s3FileProcessorService;
     _tokenManagerService    = tokenManagerService;
 }
        public async Task <IActionResult> GetItemsFromFolder(string id, string token)
        {
            try
            {
                var tokenManagerService = new TokenManagerService();
                if (tokenManagerService.ValidateToken(token, out userName, out hashKey))
                {
                    var user = await new UserService().GetUser(userName, hashKey);

                    var result = await access.GetAvailableItemsFromFolder(id, user.Id);

                    var parentFolder = await folderData.GetFolder(id);

                    var previusparent = new List <Object>()
                    {
                        new TimedModel()
                        {
                            PreviouseParent = parentFolder.ParentFolderId
                        }
                    };

                    return(Ok(result.Concat(previusparent)));
                }
                return(Unauthorized());
            }
            catch
            {
                return(BadRequest());
            }
        }
 public LoginController(IDatabaseItemService<User> userService, IDatabaseItemService<Folder> folderService, IDatabaseItemService<Note> noteService,
     IDatabaseItemService<Picture> pictureService, TokenManagerService tokenManagerService)
 {
     _userService = userService;
     _folderService = folderService;
     _noteService = noteService;
     _pictureService = pictureService;
     _tokenManagerService = tokenManagerService;
 }
 public SharedController(TokenManagerService tokenManagerService, IDatabaseItemService <Folder> folderService, IDatabaseItemService <Note> noteService,
                         IDatabaseItemService <SharedFolder> sharedFolderService, IDatabaseItemService <SharedNote> sharedNoteService, IDatabaseItemService <User> userService,
                         IDatabaseItemService <Picture> pictureService)
 {
     _tokenManagerService = tokenManagerService;
     _folderService       = folderService;
     _noteService         = noteService;
     _sharedFolderService = sharedFolderService;
     _sharedNoteService   = sharedNoteService;
     _pictureService      = pictureService;
     _userService         = userService;
 }
 public async Task<IActionResult> LoginUser(Login loginObject)
 {
     var userName = loginObject.UserName;
     var password = loginObject.UserPassword;
     
     var user = await new UserService().GetUser(userName, new HashKeyService().GetHashKey(password));
     
     if (user != null && user.ConfirmedEmail == true)
     {
         var token = new TokenManagerService().GenerateToken(userName, user.HashKey);
         return Ok(token);
     }
      
     return Unauthorized();
        public async Task <IActionResult> GetItems(string token)
        {
            try
            {
                var tokenManagerService = new TokenManagerService();
                if (tokenManagerService.ValidateToken(token, out userName, out hashKey))
                {
                    var user   = await new UserService().GetUser(userName, hashKey);
                    var result = await access.GetAvailableItems(user.Id);

                    return(Ok(result));
                }
                return(Unauthorized());
            }
            catch
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> CreateNewNoteAccess(string id, string token, [FromBody] Object inputValue)
        {
            try
            {
                var tokenManagerService = new TokenManagerService();
                if (tokenManagerService.ValidateToken(token, out userName, out hashKey))
                {
                    var userEmail = JObject.Parse(inputValue.ToString()).Value <String>("UserEmail");
                    var role      = JObject.Parse(inputValue.ToString()).Value <String>("Role");
                    var user      = await new UserService().GetUserByEmail(userEmail);

                    await access.CreateNewNoteAccess(user.Id, id, role);

                    return(Ok());
                }

                return(Unauthorized());
            }
            catch
            {
                return(BadRequest());
            }
        }
Beispiel #9
0
 public TokenServiceController(TokenManagerService tokenManagerService, ILogger <TokenServiceController> logger)
 {
     _tokenManagerService = tokenManagerService;
     _logger = logger;
 }