public async Task <IActionResult> Copy([FromRoute] Guid sourceMetricID)
        {
            var sourceMetric = await _db.Metrics
                               .Include(m => m.Domains)
                               .Include(m => m.FrameworkCategories)
                               .Where(m => m.ID == sourceMetricID).FirstOrDefaultAsync();

            if (sourceMetric == null)
            {
                return(NotFound());
            }

            //make sure only the author or a system administrator is saving metric, and they have the author metric claim
            if (!User.HasClaim(cl => cl.Type == Identity.Claims.AuthorMetric_Key))
            {
                return(BadRequest("The current user does not have permission to author a metric."));
            }

            var currentUserID = Guid.Parse(User.Claims.Where(x => x.Type == Identity.Claims.UserID_Key).Select(x => x.Value).FirstOrDefault());

            var metric = new Model.Metric
            {
                AuthorID      = currentUserID,
                Description   = sourceMetric.Description,
                Justification = sourceMetric.Justification,
                ResultsTypeID = sourceMetric.ResultsTypeID,
                Title         = sourceMetric.Title + " (Copy)"
            };

            if (sourceMetric.Domains.Any())
            {
                metric.AddDomains(sourceMetric.Domains.Select(d => d.DomainID).ToArray());
            }

            if (sourceMetric.FrameworkCategories.Any())
            {
                metric.AddFrameworkCategories(sourceMetric.FrameworkCategories.Select(f => f.DataQualityFrameworkCategoryID).ToArray());
            }

            metric.Statuses.Add(new Model.MetricStatusItem {
                MetricID = metric.ID, MetricStatusID = Model.MetricStatus.DraftID, UserID = currentUserID, Note = $"Copied from metric: \"{ sourceMetric.Title }\" [id: { sourceMetric.ID.ToString("D") }]"
            });

            _db.Metrics.Add(metric);

            await _db.SaveChangesAsync();

            return(Ok(metric.ID));
        }
        public async Task <IActionResult> New([FromBody] MetricUpdateRequest data)
        {
            if (data == null)
            {
                return(BadRequest("No data received."));
            }

            //make sure only the author or a system administrator is saving metric, and they have the author metric claim
            if (!User.HasClaim(cl => cl.Type == Identity.Claims.AuthorMetric_Key))
            {
                return(BadRequest("The current user does not have permission to author a metric."));
            }

            //TODO: validate the minimum required metadata is included

            var currentUserID = Guid.Parse(User.Claims.Where(x => x.Type == Identity.Claims.UserID_Key).Select(x => x.Value).FirstOrDefault());

            var metric = new Model.Metric {
                AuthorID        = currentUserID,
                Description     = data.Description,
                Justification   = data.Justification,
                ExpectedResults = data.ExpectedResults,
                ModifiedOn      = DateTime.UtcNow,
                ResultsTypeID   = data.ResultsTypeID,
                ServiceDeskUrl  = data.ServiceDeskUrl ?? string.Empty,
                Title           = data.Title
            };

            _db.Metrics.Add(metric);

            metric.Statuses.Add(new Model.MetricStatusItem {
                MetricID = metric.ID, MetricStatusID = Model.MetricStatus.DraftID, UserID = currentUserID
            });

            foreach (var domainID in data.Domains)
            {
                metric.AddDomains(domainID);
            }

            foreach (var frameworkCategoryID in data.FrameworkCategories)
            {
                metric.AddFrameworkCategories(frameworkCategoryID);
            }

            await _db.SaveChangesAsync();

            return(await Get(metric.ID));
        }