public MovieSeriesContract CreateMovieSeries(MovieSeriesContract contract)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new MovieSeriesDal(context);
                    var process = new MovieSeriesProcess(provider);
                    var service = new MovieSeriesService(process);

                    var result = service.Create(new MovieSeries(contract));
                    return new MovieSeries().ConvertToContract(result, new MovieSeriesContract());
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<MovieSeries, MovieSeriesContract>(exception);
            }
        }
        public DomainListContract<MovieDetailContract> FetchAllMovieDetails(bool includeDeletion)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new MovieDetailDal(context);
                    var process = new MovieDetailProcess(provider);
                    var service = new MovieDetailService(process);

                    var result = service.GetAll(includeDeletion);
                    var returnResult = new MovieDetail().ConvertToContract<MovieDetail, IEnumerable<MovieDetail>, MovieDetailContract>(result);
                    return returnResult;
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<MovieDetailContract>(exception);
            }
        }
        public DomainListContract<MovieSeriesContract> SaveAllMovieSeries(DomainListContract<MovieSeriesContract> contract)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new MovieSeriesDal(context);
                    var process = new MovieSeriesProcess(provider);
                    var service = new MovieSeriesService(process);

                    var domainList = new MovieSeries().ConvertToDomain<MovieSeries, IEnumerable<MovieSeries>, MovieSeriesContract>(contract);
                    var result = service.SaveAll(domainList);
                    var returnResult = new MovieSeries().ConvertToContract<MovieSeries, IEnumerable<MovieSeries>, MovieSeriesContract>(result);
                    return returnResult;
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<MovieSeriesContract>(exception);
            }
        }
        public DomainStatusContract RemoveMovieSeries(int id)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new MovieSeriesDal(context);
                    var process = new MovieSeriesProcess(provider);
                    var service = new MovieSeriesService(process);

                    var result = service.Remove(id);
                    return DomainStatus.ConvertToContract(result);
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse(exception);
            }
        }
        public MovieDetailContract FetchMovieDetail(int id, bool includeDeletion)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new MovieDetailDal(context);
                    var process = new MovieDetailProcess(provider);
                    var service = new MovieDetailService(process);

                    var result = service.Get(id, includeDeletion);
                    return new MovieDetail().ConvertToContract(result, new MovieDetailContract());
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<MovieDetail, MovieDetailContract>(exception);
            }
        }
        public ViewRatingTypeContract SaveViewRatingType(ViewRatingTypeContract contract)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new ViewRatingTypeDal(context);
                    var process = new ViewRatingTypeProcess(provider);
                    var service = new ViewRatingTypeService(process);

                    var result = service.Save(new ViewRatingType(contract));
                    var returnResult = new ViewRatingType().ConvertToContract(result, new ViewRatingTypeContract());
                    return returnResult;
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<ViewRatingType, ViewRatingTypeContract>(exception);
            }
        }
        public BorrowerContract SaveBorrower(BorrowerContract contract)
        {
            try
            {
                using (var context = new MovieShelfEntities(ConfigurationManager.ConnectionStrings["TestConnection"].ConnectionString))
                {
                    var provider = new BorrowerDal(context);
                    var process = new BorrowerProcess(provider);
                    var service = new BorrowerService(process);

                    var result = service.Save(new Borrower(contract));
                    return new Borrower().ConvertToContract(result, new BorrowerContract());
                }

            }
            catch (Exception exception)
            {
                return HandleExceptionResponse<Borrower, BorrowerContract>(exception);
            }
        }