private static CoreStandards ApplyPatchToCoreStandards(StandardIdentifier identifier,
                                                               CoreStandards coreStandards,
                                                               CoreStandardsXml standardsXml,
                                                               ItemPatch patch)
        {
            string claimNumber = Regex.Match(input: patch.Claim, pattern: @"\d+").Value;

            if (identifier == null)
            {
                identifier = StandardIdentifier.Create(claim: claimNumber, target: patch.Target);
            }
            else
            {
                string target = (!string.IsNullOrEmpty(patch.Target)) ? patch.Target : identifier.Target;
                claimNumber = (!string.IsNullOrEmpty(claimNumber)) ? claimNumber : identifier.Claim;
                identifier  = identifier.WithClaimAndTarget(claimNumber, target);
            }

            string targetDesc = (!string.IsNullOrEmpty(patch.TargetDescription)) ? patch.TargetDescription : coreStandards?.TargetDescription;
            string ccssDesc   = (!string.IsNullOrEmpty(patch.CCSSDescription)) ? patch.CCSSDescription : coreStandards?.CommonCoreStandardsDescription;

            coreStandards = StandardIdentifierTranslation.CoreStandardFromIdentifier(standardsXml, identifier);
            coreStandards = coreStandards.WithTargetCCSSDescriptions(targetDesc, ccssDesc);

            return(coreStandards);
        }
        public static CoreStandards CoreStandardFromIdentifier(
            CoreStandardsXml standardsXml,
            StandardIdentifier itemIdentifier)
        {
            CoreStandardsRow targetRow = null;
            CoreStandardsRow ccssRow   = null;

            if (standardsXml != null && standardsXml.TargetRows.Any())
            {
                targetRow = standardsXml.TargetRows
                            .FirstOrDefault(t =>
                                            StandardIdentifierTargetComparer.Instance.Equals(t.StandardIdentifier, itemIdentifier));
            }

            if (standardsXml != null && standardsXml.CcssRows.Any())
            {
                ccssRow = standardsXml.CcssRows
                          .FirstOrDefault(t =>
                                          StandardIdentifierCcssComparer.Instance.Equals(t.StandardIdentifier, itemIdentifier));
            }

            return(CoreStandards.Create(
                       targetId: itemIdentifier?.Target,
                       targetIdLabel: itemIdentifier?.ToTargetId(),
                       commonCoreStandardsId: itemIdentifier?.CommonCoreStandard,
                       commonCoreStandardsDescription: ccssRow?.Description,
                       targetDescription: targetRow?.Description,
                       claimId: itemIdentifier?.ToClaimId(),
                       publication: itemIdentifier?.Publication));
        }
        public void TestCoreStandardFromIdentifier()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(elaStandardString);
            var coreStandardsRowCcss      = ImmutableArray.Create(
                CoreStandardsRow.Create(
                    subjectCode: "ELA",
                    key: "3-l|4-6|6.SL.2",
                    name: "",
                    description: "CCSS Desc",
                    levelType: "CCSS",
                    identifier: identifier));

            var coreStandardsRowTarget = ImmutableArray.Create(
                CoreStandardsRow.Create(
                    subjectCode: "ELA",
                    key: "4-6|3-6",
                    name: "",
                    description: "Target Desc",
                    levelType: "Target",
                    identifier: identifier));

            CoreStandardsXml coreStandardsXml = new CoreStandardsXml(coreStandardsRowTarget, coreStandardsRowCcss);
            CoreStandards    core             = StandardIdentifierTranslation.CoreStandardFromIdentifier(coreStandardsXml, identifier);

            Assert.NotNull(core);
            Assert.Equal(core.CommonCoreStandardsId, "6.SL.2");
            Assert.Equal(core.TargetId, "4-6");
            Assert.Equal(core.TargetIdLabel, "4");
            Assert.Equal(core.TargetDescription, "Target Desc");
            Assert.Equal(core.CommonCoreStandardsDescription, "CCSS Desc");
        }
        public void TestNullCoreStandardToIdentifier()
        {
            CoreStandardsRow   coreStandardsRow = new CoreStandardsRow("", "3-l", null, null, null, null);
            StandardIdentifier identifier       = StandardIdentifierTranslation.CoreStandardToIdentifier(coreStandardsRow);

            Assert.Null(identifier);
        }
        public void TestElaV1Translation()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(elaStandardString);

            Assert.Equal("3-L", identifier.Claim);
            Assert.Equal("4-6", identifier.Target);
            Assert.Equal("6.SL.2", identifier.CommonCoreStandard);
        }
        public void TestMathNotEqualCCSS()
        {
            StandardIdentifier x = DefaultWith(subjectCode: subjectMath);
            StandardIdentifier y = DefaultWith(subjectCode: subjectMath, commonCoreStandard: Ccss2);

            Assert.False(StandardIdentifierCcssComparer.Instance.Equals(x, y));
            Assert.True(StandardIdentifierTargetComparer.Instance.Equals(x, y));
        }
        public void TestMathNotEqualEmphasis()
        {
            StandardIdentifier x = DefaultWith(subjectCode: subjectMath);
            StandardIdentifier y = DefaultWith(subjectCode: subjectMath, contentDomain: emphasis2);

            Assert.False(StandardIdentifierCcssComparer.Instance.Equals(x, y));
            Assert.False(StandardIdentifierTargetComparer.Instance.Equals(x, y));
        }
        public void TestElaNotEqualTarget()
        {
            StandardIdentifier x = DefaultWith(subjectCode: subjectEla);
            StandardIdentifier y = DefaultWith(subjectCode: subjectEla, target: target2);

            Assert.False(StandardIdentifierCcssComparer.Instance.Equals(x, y));
            Assert.False(StandardIdentifierTargetComparer.Instance.Equals(x, y));
        }
        public void TestElaCoreStandardToTarget()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.ElaCoreStandardToTarget(new string[] { "4-6", "3-6" });

            Assert.Equal("4-6", identifier.Claim);
            Assert.Equal("3-6", identifier.Target);
            Assert.Equal("ELA", identifier.SubjectCode);
        }
        public void TestInvalidMathV1String()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(invalidMathV1StandardString);

            Assert.Equal("1", identifier.Claim);
            Assert.Equal(string.Empty, identifier.Target);
            Assert.Equal(string.Empty, identifier.CommonCoreStandard);
        }
        public void TestMathEqual()
        {
            StandardIdentifier x = DefaultWith(subjectMath);
            StandardIdentifier y = DefaultWith(subjectMath);

            Assert.True(StandardIdentifierCcssComparer.Instance.Equals(x, y));
            Assert.True(StandardIdentifierTargetComparer.Instance.Equals(x, y));
        }
        public void TestMathCoreStandardToTarget()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.MathCoreStandardToTarget(new string[] { "1", "NBT", "E-3" });

            Assert.Equal("1", identifier.Claim);
            Assert.Equal("NBT", identifier.ContentDomain);
            Assert.Equal("E-3", identifier.Target);
            Assert.Equal("MATH", identifier.SubjectCode);
        }
        public void TestInvalidMathV6String()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(invalidMathV6StandardString);

            Assert.Equal("3", identifier.Claim);
            Assert.Equal(string.Empty, identifier.ContentCategory);
            Assert.Equal(string.Empty, identifier.TargetSet);
            Assert.Equal(string.Empty, identifier.TargetSet);
        }
 public static StandardIdentifier ElaV1Standard(string[] parts, string publication)
 {
     return(StandardIdentifier.Create(
                claim: GetStandardPartOrDefault(parts, 0),
                target: GetStandardPartOrDefault(parts, 1),
                commonCoreStandard: GetStandardPartOrDefault(parts, 2),
                subjectCode: "ELA",
                publication: publication));
 }
        public void TestMathV6Translation()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(mathV6StandardString);

            Assert.Equal("3", identifier.Claim);
            Assert.Equal("D-6", identifier.Target);
            Assert.Equal("P", identifier.ContentCategory);
            Assert.Equal("TS04", identifier.TargetSet);
        }
        public void TestMathV1Translation()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(mathv1StandardString);

            Assert.Equal("1", identifier.Claim);
            Assert.Equal("NBT", identifier.ContentDomain);
            Assert.Equal("E-3", identifier.Target);
            Assert.Equal("3.NBT.2", identifier.CommonCoreStandard);
        }
        public void TestCoreStandardToIdentifierELATarget()
        {
            CoreStandardsRow   coreStandardsRow = new CoreStandardsRow("ELA", "4-6|3-6", "", "", "Target", null);
            StandardIdentifier identifier       = StandardIdentifierTranslation.CoreStandardToIdentifier(coreStandardsRow);

            Assert.Equal("4-6", identifier.Claim);
            Assert.Equal("3-6", identifier.Target);
            Assert.Equal("ELA", identifier.SubjectCode);
        }
        public void TestCoreStandardToIdentifierMathTarget()
        {
            CoreStandardsRow   coreStandardsRow = new CoreStandardsRow("MATH", "1|NBT|E-3", "", "", "Target", null);
            StandardIdentifier identifier       = StandardIdentifierTranslation.CoreStandardToIdentifier(coreStandardsRow);

            Assert.Equal("1", identifier.Claim);
            Assert.Equal("NBT", identifier.ContentDomain);
            Assert.Equal("E-3", identifier.Target);
            Assert.Equal("MATH", identifier.SubjectCode);
        }
 public static StandardIdentifier MaV6Standard(string[] parts, string publication)
 {
     return(StandardIdentifier.Create(
                claim: GetStandardPartOrDefault(parts, 0),
                target: GetStandardPartOrDefault(parts, 3),
                contentCategory: GetStandardPartOrDefault(parts, 1),
                targetSet: GetStandardPartOrDefault(parts, 2),
                subjectCode: "MATH",
                publication: publication));
 }
        public void TestMathV5Translation()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(mathV5StandardString);

            Assert.Equal("2", identifier.Claim);
            Assert.Equal("D-6", identifier.Target);
            Assert.Equal("6.NS.6c", identifier.CommonCoreStandard);
            Assert.Equal("NS", identifier.ContentDomain);
            Assert.Equal("m", identifier.Emphasis);
        }
        public void TestInvalidMathV5String()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(invalidMathV5StandardString);

            Assert.Equal("2", identifier.Claim);
            Assert.Equal("6.NS.6c", identifier.CommonCoreStandard);
            Assert.Equal(string.Empty, identifier.Target);
            Assert.Equal(string.Empty, identifier.ContentDomain);
            Assert.Equal(string.Empty, identifier.Emphasis);
        }
        public void TestCoreStandardToIdentifierMathCcss()
        {
            CoreStandardsRow   coreStandardsRow = new CoreStandardsRow("MATH", "1|NBT|E-3|a/s|3.NBT.2", "", "", "CCSS", null);
            StandardIdentifier identifier       = StandardIdentifierTranslation.CoreStandardToIdentifier(coreStandardsRow);

            Assert.Equal("1", identifier.Claim);
            Assert.Equal("NBT", identifier.ContentDomain);
            Assert.Equal("E-3", identifier.Target);
            Assert.Equal("3.NBT.2", identifier.CommonCoreStandard);
        }
        public void TestCoreStandardToIdentifierELACcss()
        {
            CoreStandardsRow   coreStandardsRow = new CoreStandardsRow("ELA", "3-l|4-6|6.SL.2", "", "", "CCSS", null);
            StandardIdentifier identifier       = StandardIdentifierTranslation.CoreStandardToIdentifier(coreStandardsRow);

            Assert.Equal("3-l", identifier.Claim);
            Assert.Equal("4-6", identifier.Target);
            Assert.Equal("6.SL.2", identifier.CommonCoreStandard);
            Assert.Equal("ELA", identifier.SubjectCode);
        }
        public void TestMathCoreStandardToCcss()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.MathCoreStandardToCcss(new string[] { "4-6", "NS", "3-6", "m", "6.NS.6c" });

            Assert.Equal("4-6", identifier.Claim);
            Assert.Equal("3-6", identifier.Target);
            Assert.Equal("6.NS.6c", identifier.CommonCoreStandard);
            Assert.Equal("NS", identifier.ContentDomain);
            Assert.Equal("MATH", identifier.SubjectCode);
        }
        /*
         * Locate and parse the standard, claim, and target from the metadata
         *
         * Claim and target are specified in one of the following formats:
         * SBAC-ELA-v1 (there is only one alignment for ELA, this is used for delivery)
         *     Claim|Assessment Target|Common Core Standard
         * SBAC-MA-v6 (Math, based on the blueprint hierarchy, primary alignment and does not go to standard level, THIS IS USED FOR DELIVERY, should be the same as SBAC-MA-v4)
         *     Claim|Content Category|Target Set|Assessment Target
         * SBAC-MA-v5 (Math, based on the content specifications hierarchy secondary alignment to the standard level)
         *     Claim|Content Domain|Target|Emphasis|Common Core Standard
         * SBAC-MA-v4 (Math, based on the content specifications hierarchy primary alignment to the standard level)
         *     Claim|Content Domain|Target|Emphasis|Common Core Standard
         */

        public static StandardIdentifier StandardStringToStandardIdentifier(string standards)
        {
            if (string.IsNullOrEmpty(standards))
            {
                // TODO: log error
                return(null);
            }

            string[] publicationAndKey = standards.Split(':');

            if (publicationAndKey.Length < 2)
            {
                return(null);

                // TODO: log error instead
                //throw new ArgumentException("The standards string does not contain a publication and claim spearated by a colon.");
            }

            StandardIdentifier standardIdentifier = null;

            string publication = publicationAndKey[0];

            string[] parts = publicationAndKey[1].Split('|');

            switch (publication)
            {
            case "SBAC-ELA-v1":
                standardIdentifier = ElaV1Standard(parts, standards);
                break;

            case "SBAC-MA-v1":
                standardIdentifier = MaV1Standard(parts, standards);
                break;

            case "SBAC-MA-v4":
                standardIdentifier = MaV4Standard(parts, standards);
                break;

            case "SBAC-MA-v5":
                standardIdentifier = MaV5Standard(parts, standards);
                break;

            case "SBAC-MA-v6":
                standardIdentifier = MaV6Standard(parts, standards);
                break;
            }

            if (standardIdentifier == null)
            {
                standardIdentifier = StandardIdentifier.Create(
                    claim: parts[0]);
            }

            return(standardIdentifier);
        }
 public static StandardIdentifier MaV5Standard(string[] parts, string publication)
 {
     return(StandardIdentifier.Create(
                claim: GetStandardPartOrDefault(parts, 0),
                target: GetStandardPartOrDefault(parts, 2),
                contentDomain: GetStandardPartOrDefault(parts, 1),
                emphasis: GetStandardPartOrDefault(parts, 3),
                commonCoreStandard: GetStandardPartOrDefault(parts, 4),
                subjectCode: "MATH",
                publication: publication));
 }
        public void TestToTargetId()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(elaStandardString);
            var targetId = StandardIdentifierTranslation.ToTargetId(identifier);

            identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(noTargetString);
            var noTargetId = StandardIdentifierTranslation.ToTargetId(identifier);

            Assert.Equal("4", targetId);
            Assert.Equal(string.Empty, noTargetId);
        }
        public void TestToClaimId()
        {
            StandardIdentifier identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(elaStandardString);
            var claimId = StandardIdentifierTranslation.ToClaimId(identifier);

            identifier = StandardIdentifierTranslation.StandardStringToStandardIdentifier(noClaimString);
            var noClaimId = StandardIdentifierTranslation.ToClaimId(identifier);

            Assert.Equal("3", claimId);
            Assert.Equal(string.Empty, noClaimId);
        }
        public static StandardIdentifier ElaCoreStandardToTarget(string[] parts)
        {
            if (parts == null || parts.Length != 2)
            {
                return(null);
            }

            return(StandardIdentifier.Create(
                       claim: parts[0],
                       target: parts[1],
                       subjectCode: "ELA"));
        }
        public void TestToStandardIdentifierGoodDigest()
        {
            ItemDigest         digest     = ItemDigestTranslation.ToItemDigest(metadata, contents, appSettings);
            StandardIdentifier identifier = StandardIdentifierTranslation.ToStandardIdentifier(digest, new string[] { "SBAC-MA-v1" });

            Assert.NotNull(identifier);
            Assert.Equal(digest.SubjectCode, identifier.SubjectCode);
            Assert.Equal("1", identifier.Claim);
            Assert.Equal("3.NBT.2", identifier.CommonCoreStandard);
            Assert.Equal("NBT", identifier.ContentDomain);
            Assert.Equal("E-3", identifier.Target);
        }