public async Task <SurfReport> Post([FromBody] SurfReportContract clientReport)
        {
            var report           = clientReport.ToDomain();
            ValidationResult vld = await ValidatorSvc.ValidateSurfReport(report);

            if (!vld.Success)
            {
                Response.StatusCode = 400;
                var jsonString = JsonConvert.SerializeObject(vld);
                Response.ContentType = new MediaTypeHeaderValue("application/json").ToString();
                await Response.WriteAsync(jsonString, Encoding.UTF8);

                return(null);
            }
            SurfReport rtn = null;

            if (vld.Success)
            {
                rtn = await UserReportsSvc.SaveSurfReport(report);
            }
            //this happens if the given poster has already provided a report for the day
            //TODO: handle this more elegantly
            if (rtn == null && vld.Success)
            {
                Response.StatusCode = 204;
                var jsonString = "{\"message\":\"You have already submitted a report for today.\"}";
                Response.ContentType = new MediaTypeHeaderValue("application/json").ToString();
                await Response.WriteAsync(jsonString, Encoding.UTF8);

                return(null);
            }
            return(rtn);
        }
        public async Task <ValidationResult> ValidateSurfReport(SurfReport report)
        {
            ValidationResult rtn = new ValidationResult();
            //There may be a better way to do this, but the generic arguments required from the serialization library don't allow you to pass in a more derived type and get
            //return type covariance. Although I always seem to run into this problem in C#.... So, we need to manually validate against the known base types.
            var baseResult = this.ValidateEntity <ReportBase>(report as ReportBase);
            var coreResult = this.ValidateEntity <SurfReport>(report);
            //These two tasks can be run in parallel. So do it.
            await Task.WhenAll(baseResult, coreResult);

            //I don't really know how to use a synchronous continue with call, so let's just force synchrocity this way
            rtn.AddValidationResults(new ValidationResult[2] {
                baseResult.Result, coreResult.Result
            });
            return(rtn);
        }
        public async Task <SurfReport> Get(long id)
        {
            SurfReport report = await UserReportsSvc.GetSurfReport(id);

            return(report);
        }
 public Task <SurfReport> SaveSurfReport(SurfReport report)
 {
     return(this.SaveReport <SurfReport>(report));
 }