Example #1
0
        public async Task <Result <bool> > UpdateSeries([FromBody] ImportSeriesDto request)
        {
            try
            {
                if (request.Title == null)
                {
                    Response.StatusCode = (int)HttpStatusCode.BadRequest;
                    return(new Result <bool>
                    {
                        Data = false,
                        ResultCode = (int)CoreCodes.MalformedRequest,
                        ResultMessage = "All of the fields must be filled up."
                    });
                }

                await _seriesService.UpdateSeries(request.Title);
            }
            catch (InternalException ex)
            {
                if (ex.ErrorCode == (int)CoreCodes.UpToDate)
                {
                    Response.StatusCode = (int)HttpStatusCode.NotModified;
                    return(new Result <bool>
                    {
                        Data = false,
                        ResultCode = ex.ErrorCode,
                        ResultMessage = ex.ErrorMessage
                    });
                }

                if (ex.ErrorCode == (int)CoreCodes.UpdateFailed)
                {
                    Response.StatusCode = (int)HttpStatusCode.NotModified;
                    return(new Result <bool>
                    {
                        Data = false,
                        ResultCode = ex.ErrorCode,
                        ResultMessage = ex.ErrorMessage
                    });
                }
            }
            catch (Exception ex)
            {
                Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                return(new Result <bool>
                {
                    Data = false,
                    ResultCode = (int)CoreCodes.CommonGenericError,
                    ResultMessage = "Common Generic Error --" + ex.Message
                });
            }


            return(new Result <bool>
            {
                Data = true,
                ResultCode = (int)CoreCodes.NoError,
                ResultMessage = "Successfully updated."
            });
        }
Example #2
0
        public async Task <int> IsShowExist(ImportSeriesDto series)
        {
            if (series != null)
            {
                if (await IsMediaExistInMongoDb(series.Title))
                {
                    return((int)MediaExistIn.MONGO);
                }
                series.Title = RemoveAccent(series.Title);
                var tvmazexist = await IsMediaExistInTvMaze(series.Title);

                var tmdbexist = await IsMediaExistInTmdb(series.Title);

                if (tvmazexist)
                {
                    if (tmdbexist)
                    {
                        return((int)MediaExistIn.TMDB);
                    }
                    return((int)MediaExistIn.TVMAZE);
                }
                return((int)MediaExistIn.NONE);
            }
            return((int)MediaExistIn.REQUESTERROR);
        }
Example #3
0
        public async Task <Result <bool> > ImportSeries([FromBody] ImportSeriesDto request)
        {
            try
            {
                if (string.IsNullOrEmpty(request.Title))
                {
                    Response.StatusCode = (int)HttpStatusCode.BadRequest;
                    return(new Result <bool>
                    {
                        Data = false,
                        ResultCode = (int)CoreCodes.MalformedRequest,
                        ResultMessage = "The title cannot be empty."
                    });
                }

                await _seriesService.ImportSeries(request.Title);
            }
            catch (InternalException ex)
            {
                if (ex.ErrorCode == (int)CoreCodes.AlreadyImported)
                {
                    Response.StatusCode = (int)HttpStatusCode.Conflict;
                    return(new Result <bool>
                    {
                        Data = false,
                        ResultCode = ex.ErrorCode,
                        ResultMessage = ex.ErrorMessage
                    });
                }
            }
            catch (Exception e)
            {
                Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                return(new Result <bool>
                {
                    Data = false,
                    ResultCode = (int)CoreCodes.CommonGenericError,
                    ResultMessage = "Common Generic Error --" + e.Message
                });
            }

            return(new Result <bool>
            {
                Data = true,
                ResultCode = (int)CoreCodes.NoError,
                ResultMessage = "Successfully imported."
            });
        }
Example #4
0
        public async Task <Result <int> > IsShowExist([FromBody] ImportSeriesDto request)
        {
            try
            {
                if (request.Title == null)
                {
                    Response.StatusCode = (int)HttpStatusCode.BadRequest;
                    return(new Result <int>
                    {
                        Data = 0,
                        ResultCode = (int)CoreCodes.MalformedRequest,
                        ResultMessage = "All of the fields must be filled up."
                    });
                }

                var existEnumType = await _seriesService.IsShowExist(request);

                var enumVal = (MediaExistIn)existEnumType;
                return(new Result <int>
                {
                    Data = existEnumType,
                    ResultCode = (int)HttpStatusCode.OK,
                    ResultMessage = "It exists in" + enumVal.ToString()
                });
            }
            catch (InternalException ex)
            {
                if (ex.ErrorCode == (int)CoreCodes.EpisodeNotFound)
                {
                    Response.StatusCode = (int)CoreCodes.EpisodeNotFound;
                    return(new Result <int>
                    {
                        Data = 0,
                        ResultCode = ex.ErrorCode,
                        ResultMessage = ex.ErrorMessage
                    });
                }

                if (ex.ErrorCode == (int)CoreCodes.SeriesNotFound)
                {
                    Response.StatusCode = (int)CoreCodes.SeriesNotFound;
                    return(new Result <int>
                    {
                        Data = 0,
                        ResultCode = ex.ErrorCode,
                        ResultMessage = ex.ErrorMessage
                    });
                }
            }
            catch (Exception ex)
            {
                Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                return(new Result <int>
                {
                    Data = 0,
                    ResultCode = (int)CoreCodes.CommonGenericError,
                    ResultMessage = "Common Generic Error -- " + ex.Message
                });
            }

            return(new Result <int>
            {
                Data = 0,
                ResultCode = (int)CoreCodes.SeriesNotFound,
                ResultMessage = "Show doesn't exist."
            });
        }