RestService

/******************************************************************************
 * RestService.java - Service calls that want session protection
 * $Id: RestService.java,v 1.16 2015/05/11 01:57:54 dick Exp $
 *
 * BuckoVidLib - The BuckoSoft Video Library
 * Copyright(c) 2015 - Dick Balaska
 *
 * $Log: RestService.java,v $
 * Revision 1.16  2015/05/11 01:57:54  dick
 * /statistics wants a session so we don't count restricted movies.
 *
 * Revision 1.15  2015/05/08 02:37:14  dick
 * findVideosAndThings(key, max) returns videos, actors, directors, and writers
 *
 * Revision 1.14  2015/05/07 00:15:38  dick
 * findMaxResults is a user config option.
 *
 * Revision 1.13  2015/05/06 17:05:00  dick
 * findVideos() looks up videos by partial strings.
 *
 * Revision 1.12  2015/05/06 03:36:53  dick
 * hideRestricted allows a user with restricted access to temporarily turn it off.
 *
 * Revision 1.11  2015/05/05 04:26:00  dick
 * Persist backgroundDelay and artShowDelay.
 *
 * Revision 1.10  2015/05/04 20:36:50  dick
 * getBackgroundFit() needs to know if we are running the ArtShow, which may be different
 * than the normal backgroundFit.
 *
 * Revision 1.9  2015/05/04 05:46:27  dick
 * Always output OK for /config/backgroundFit.
 *
 * Revision 1.8  2015/05/03 17:53:46  dick
 * /configBackground lets the User configure his background type.
 *
 * Revision 1.7  2015/05/01 19:59:27  dick
 * Return 204 No Content if the database isn't ready.
 *
 * Revision 1.6  2015/04/30 14:51:13  dick
 * Load prettyPrint from a properties.
 *
 * Revision 1.5  2015/04/30 06:34:27  dick
 * Getting lists of VideoBase is always protected by session.
 *
 * Revision 1.4  2015/04/30 03:18:03  dick
 * Deal mostly with VideoBase. Only fetch full Video when we really need it.
 * Protect all (most) calls to the restricted section of the library by session.
 *
 * Revision 1.3  2015/04/29 14:34:08  dick
 * Break up Video into base class VideoBase and Video.
 * All of the parts to define a Video are in VideoBase.
 * The idea is that I'm going to be throwing a lot of these things around, and I really don't
 * want the memory baggage of Summaries and Actor Lists, when really, I just want the
 * name of the video.
 *
 * Revision 1.2  2015/04/28 09:56:41  dick
 * status returns a 204 No Content if the database isn't ready.
 *
 * Revision 1.1  2015/04/27 15:15:10  dick
 * Handle REST service calls that want session protection.
 *
 */
package com.buckosoft.BuckoVidLib.web;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import com.buckosoft.BSAccount.BSAccountMan;
import com.buckosoft.BuckoVidLib.business.BuckoVidLib;
import com.buckosoft.BuckoVidLib.domain.LibrarySection;
import com.buckosoft.BuckoVidLib.domain.User;
import com.buckosoft.BuckoVidLib.domain.UserWebSession;
import com.buckosoft.BuckoVidLib.domain.Video;
import com.buckosoft.BuckoVidLib.domain.VideoBase;
import com.buckosoft.BuckoVidLib.domain.rest.RestDetailedVideo;
import com.buckosoft.BuckoVidLib.domain.rest.RestLibrarySection;
import com.buckosoft.BuckoVidLib.domain.rest.RestLibrarySections;
import com.buckosoft.BuckoVidLib.domain.rest.RestLibraryStatus;
import com.buckosoft.BuckoVidLib.domain.rest.RestStatistics;
import com.buckosoft.BuckoVidLib.domain.rest.RestVideo;
import com.buckosoft.BuckoVidLib.domain.rest.RestVideos;
import com.buckosoft.BuckoVidLib.util.ConfigManager;
import com.buckosoft.BuckoVidLib.util.DomainConverter;

/** Handle REST service calls that want session protection.
 * Some calls are only allowed access to the restricted sections by login session.
 *
 * The CXF way that I was using doesn't seem to support HttpServletRequest, which is where the session is stashed.
 * So for now, keep the unprotected calls over in BVLRestService and put the protected calls here.
 * @author dick
 * @since 2015-04-27
 *
 */
@Controller
@RequestMapping("/rs")
public class RestService {
	private final Log log = LogFactory.getLog(getClass());

	private	boolean logExceptions = true;
	private	boolean prettyPrint = true;

	@Autowired
	BSAccountMan	bsAccountMan;

	@Autowired
	private BuckoVidLib		bvl;

	public RestService() {
		prettyPrint = ConfigManager.getBoolean("BuckoVidLib.prettyPrint", true);
		logExceptions = ConfigManager.getBoolean("BuckoVidLib.logExceptions", true);
	}

	@RequestMapping(value="/libraryList", produces=MediaType.APPLICATION_XML_VALUE)
	public void libraryList(HttpServletRequest request, OutputStream os) throws Exception {
		boolean allowRestricted = bvl.isAllowRestricted(request);
		List<LibrarySection> llist = bvl.getSectionList(allowRestricted);
		List<RestLibrarySection> rlist = new ArrayList<RestLibrarySection>();
		for (LibrarySection l : llist) {
			RestLibrarySection rl = new RestLibrarySection();
			rl.setKey(l.getKey());
			rl.setName(l.getName());
			rl.setVideoCount(l.getVideoCount());
			rlist.add(rl);
		}
		Collections.sort(rlist, new CountSort());
		RestLibrarySections rls = new RestLibrarySections();
		rls.setLibrarySections(rlist);
		JAXBContext context = JAXBContext.newInstance(RestLibrarySections.class);
		Marshaller m = context.createMarshaller();
		m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, prettyPrint);
		m.marshal(rls, os);
	}

	@RequestMapping(value="/status", produces=MediaType.APPLICATION_XML_VALUE)
	public void libraryStatus(HttpServletRequest request,  HttpServletResponse response) throws JAXBException {
		libraryStatus(request, response, 1);
	}

	@RequestMapping(value="/status/{count}", produces=MediaType.APPLICATION_XML_VALUE)
	public void libraryStatus(HttpServletRequest request, HttpServletResponse response, @PathVariable("count") Integer count) {
		if (count == null)
			count = 1;
		RestLibraryStatus rls = new RestLibraryStatus();
		List<VideoBase> vv = bvl.getRecentlyAdded(count, bvl.isAllowRestricted(request));
		ArrayList<RestVideo> al = new ArrayList<RestVideo>();
		try {
			if (vv == null) {
				response.sendError(204, "No content");
				log.info("Returning 204 no content");
				return;
			}
			for (VideoBase v : vv)
				al.add(DomainConverter.toRestVideo(v));
			rls.setRecentlyAddedVideos(al);
			try {
				rls.setLastUpdated(bvl.getLastUpdateTime());
			} catch (Exception e) {
				response.sendError(204, "No content");
				log.info("Returning 204 no content");
				return;
			}
			JAXBContext context;
			context = JAXBContext.newInstance(RestLibraryStatus.class);
			Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, prettyPrint);
			OutputStream os;
			os = response.getOutputStream();
			m.marshal(rls, os);
		} catch (IOException | JAXBException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/statistics", produces=MediaType.APPLICATION_XML_VALUE)
	public void statistics(HttpServletRequest request, HttpServletResponse response) {
		RestStatistics rs = new RestStatistics();
		boolean allowRestricted =  bvl.isAllowRestricted(request);
		int ep = bvl.getTVEpisodeCount(allowRestricted);
		int m = bvl.getMovieCount(allowRestricted);
		rs.setMovieCount(m);
		rs.setTvShowCount(bvl.getTVShowCount(allowRestricted));
		rs.setEpisodeCount(ep);
		rs.setVideoCount(ep + m);
		outputXml(response, rs);
	}


	@RequestMapping(value="/detailedVideo/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void detailedVideo(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") String key) {
		int k = DomainConverter.keyToInt(key);
		Video v = bvl.getVideoFromKey(k, bvl.isAllowRestricted(request));
		try {
			if (v == null) {
				response.sendError(204, "Video not found");
				return;
			}
			RestDetailedVideo rdv = DomainConverter.toRestDetailedVideo(v);
			outputXml(response, rdv);
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/randomVideo", produces=MediaType.APPLICATION_XML_VALUE)
	public void	randomVideo(HttpServletRequest request, HttpServletResponse response) {
		boolean allowRestricted = bvl.isAllowRestricted(request);
		try {
			RestVideo v = bvl.getRandomMovie(allowRestricted);
			if (v == null) {
				response.sendError(204, "Video not found");
				return;
			}
			outputXml(response, v);
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/videos/recent/{count}", produces=MediaType.APPLICATION_XML_VALUE)
	public void recentVideos(HttpServletRequest request, HttpServletResponse response, @PathVariable("count") Integer count) {
		List<VideoBase> vl = bvl.getRecentlyAdded(count, bvl.isAllowRestricted(request));
		outputVideos(response, vl);
	}

	@RequestMapping(value="/videos/section/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void sectionVideos(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") Integer key) {
		List<VideoBase> vl = bvl.getLibraryListVideos(key);
		outputVideos(response, vl);
	}
	@RequestMapping(value="/videos/director/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void directorVideos(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") Integer key) {
		List<VideoBase> vl = bvl.getDirectorVideos(key);
		outputVideos(response, vl);
	}

	@RequestMapping(value="/videos/actor/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void actorVideos(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") Integer key) {
		List<VideoBase> vl = bvl.getActorVideos(key);
		outputVideos(response, vl);
	}
	@RequestMapping(value="/videos/writer/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void writerVideos(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") Integer key) {
		List<VideoBase> vl = bvl.getWriterVideos(key);
		outputVideos(response, vl);
	}

	@RequestMapping(value="/videos/find/{key}", produces=MediaType.APPLICATION_XML_VALUE)
	public void findVideosAndThings(HttpServletRequest request, HttpServletResponse response, @PathVariable("key") String key) {
		boolean allowRestricted = bvl.isAllowRestricted(request);
		List<RestVideo> vl = bvl.findVideosAndThings(key, allowRestricted, bvl.getFindMaxResults(request));
		outputRestVideos(response, vl);
	}

	private	void outputVideos(HttpServletResponse response, List<VideoBase> videos) {
		List<RestVideo> rvl = new ArrayList<RestVideo>();
		for (VideoBase v : videos)
			rvl.add(DomainConverter.toRestVideo(v));
		outputRestVideos(response, rvl);
	}
	private	void outputRestVideos(HttpServletResponse response, List<RestVideo> videos) {
		RestVideos rvs = new RestVideos();
		rvs.setVideos(videos);
		outputXml(response, rvs);
	}
	private class CountSort implements Comparator<RestLibrarySection> {
		@Override
		public int compare(RestLibrarySection arg0, RestLibrarySection arg1) {
			return(Integer.compare(arg1.getVideoCount(), arg0.getVideoCount()));
		}
	}

	private void outputXml(HttpServletResponse response, Object object) {
		try {
			JAXBContext context = JAXBContext.newInstance(object.getClass());
			Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, prettyPrint);
			OutputStream os = response.getOutputStream();
			m.marshal(object, os);
		} catch (JAXBException | IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}

	}

	@RequestMapping(value="/config/backgroundFit/{value}", produces=MediaType.TEXT_PLAIN_VALUE)
	public void configBackgroundFit(HttpServletRequest request, HttpServletResponse response, @PathVariable("value") Integer value) {
		UserWebSession userWebSession = (UserWebSession)this.bsAccountMan.getUserWebSession(request);
		User user = (User)userWebSession.getUser();
		log.info("backgroundFit: userWebSession = " + userWebSession);
		bvl.setBackgroundFit(request, value);
		log.info("setBackgroundFit to " + value + " (artShowFit = " + user.getArtShowFit() + ")");
		try {
			response.getWriter().print("OK");
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/config/backgroundDelays/{background}/{artShow}/{max}", produces=MediaType.TEXT_PLAIN_VALUE)
	public void configBackgroundDelays(HttpServletRequest request, HttpServletResponse response,
			@PathVariable("background") Integer background, @PathVariable("artShow") Integer artShow,
			@PathVariable("max") Integer findMaxResults) {
		UserWebSession userWebSession = (UserWebSession)this.bsAccountMan.getUserWebSession(request);
		bvl.setBackgroundDelays(request, background, artShow);
		bvl.setFindMaxResults(request, findMaxResults);
		log.info("configBackgroundDelays: userWebSession = " + userWebSession);
		log.info("configBackgroundDelays to " + background + " artShow: " + artShow + " maxFind: " + findMaxResults);
		try {
			response.getWriter().print("OK");
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/config/hideRestricted/{hide}", produces=MediaType.TEXT_PLAIN_VALUE)
	public void configHideRestricted(HttpServletRequest request, HttpServletResponse response,
			@PathVariable("hide") Boolean hideRestricted) {
		UserWebSession userWebSession = (UserWebSession)this.bsAccountMan.getUserWebSession(request);
		bvl.setHideRestricted(request, hideRestricted);
		log.info("configHideRestricted: userWebSession = " + userWebSession);
		log.info("configHideRestricted to " + hideRestricted);
		try {
			response.getWriter().print("OK");
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}

	@RequestMapping(value="/config/findMaxResults/{max}", produces=MediaType.TEXT_PLAIN_VALUE)
	public void configFindMaxResults(HttpServletRequest request, HttpServletResponse response,
			@PathVariable("max") Integer findMaxResults) {
		UserWebSession userWebSession = (UserWebSession)this.bsAccountMan.getUserWebSession(request);
		bvl.setFindMaxResults(request, findMaxResults);
		log.info("configFindMaxResults: userWebSession = " + userWebSession);
		log.info("configFindMaxResults to " + findMaxResults);
		try {
			response.getWriter().print("OK");
		} catch (IOException e) {
			if (logExceptions)
				e.printStackTrace();
			else
				log.warn(e.getMessage());
		}
	}
}