---
# System prepended metadata

title: Untitled

---

```
@Entity
@Table(name = "watchlist_entry")
@NamedQueries({
 @NamedQuery("WatchlistEntry.findByUser", "select WatchlistEntry w where w.user = :user")
})
public class WatchlistEntry implements Serializable {
   private static final long serialVersionUID = 1L;

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "id")
   private Long id;

   @ManyToOne
   @JoinColumn(name = "user_id", nullable = false)
   private User user;

   @ManyToOne
   @JoinColumn(name = "video_id", nullable = false)
   private Video video;

   @Column(name = "display_order", nullable = false)
   private int displayOrder;

   public WatchlistEntry() { }

   public WatchlistEntry(User user, Video video, int displayOrder) {
       this.user = user;
       this.video = video;
       this.displayOrder = displayOrder;
   }

   public WatchlistEntry(long userId, long videoId, int displayOrder) {
       this(new User(userId), new Video(videoId), displayOrder);
   }

  // assume getters and setters for all instance variables
}
```
```
public class WatchlistController {

   private final Long userId;
   private final WatchlistService watchlistService;

   @Inject
   public WatchlistController(final @Qualifier("userId") Long userId, final WatchlistService watchlistService) {
       this.userId = userId;
       this.watchlistService = watchlistService;
   }

   /**
    * Retrieves and returns the list of watchlist entries, sorted by display order asc.
    * @return List of watchlist entries
    */
   @GetMapping("/v1/watchlist")
   public List<WatchlistEntry> getWatchlistEntries() {
       // TODO: implement
       //
       

   @PostMapping("/v1/watchlist")
   public Watchlist saveWatchlistEntry(@Valid @RequestBody final WatchlistEntryBody watchlistEntryBody) {
       // watchlist request form body is validated before transforming to the JPA model equivalent
       return watchlistService.save(new WatchlistEntry(userId, watchlistEntryBody.getVideoId(), watchlistEntryBody.getDisplayOrder()));
   }

   @DeleteMapping("/v1/watchlist/{id}")
   public Watchlist deleteWatchlistEntry(@PathVariable final long id) {
       return watchlistService.delete(userId, id);
   }
}


```


```
@Service
public class WatchlistServiceImpl implements WatchlistService {

   private final EntityManager em;

   @Autowired
   public WatchlistServiceImpl(final EntityManager em) {
       this.em = em;
   }

   @Override
   public List<WatchlistEntry> getAll(final long userId) {
       return em.createNamedQuery("WatchlistEntry.findByUser", WatchlistEntry.class)
               .setParameter("user", new User(userId))
               .getResultList();
   }

   /**
    * Save a new watchlist entry with the following business logic:
    *   If display order is within the range of existing watchlist entry display orders, increment display orders for rows being displaced.
    *   If display order is greater than the max of existing watchlist entry display orders, set display order to end of range.
    * @param watchlist Watchlist Entry to be saved
    * @return Saved watchlist
    * @throws IllegalArgumentException Bad watchlist input
    */
//Display order: 1-based, sequential, unique
   @Override
   @Transactional
   public WatchlistEntry save(final WatchlistEntry watchlistEntry) {
		
       // TODO: implement
       //


   /**
    * Delete a watchlist entry by id with the following business logic:
    *   Handle security on the watchlist entry . Ensure that the session user id has access to the watchlist.
    *   Upon deleting the watchlist entry, reorder any watchlist entry display orders for user that break display order linearity.
    * @param userId User id
    * @param id Video id
    * @return WatchlistEntry deleted
    * @throws IllegalArgumentException Bad userId or id input
    */
  


 @Override
   @Transactional
   public WatchlistEntry delete(final long userId, final long id) {
       // TODO: implement
       //
	


   }
}



```