< Summary

Information
Class: RoleRadar.Domain.Tracking.TrackingEnumExtensions
Assembly: RoleRadar.Domain
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Tracking/TrackingEnums.cs
Line coverage
85%
Covered lines: 227
Uncovered lines: 37
Coverable lines: 264
Total lines: 577
Line coverage: 85.9%
Branch coverage
81%
Covered branches: 230
Total branches: 281
Branch coverage: 81.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ToSnakeCase(...)87.5%8890.9%
TryParseDisposition(...)95.45%222291.66%
ToSnakeCase(...)75%4483.33%
TryParseResurfacePolicy(...)83.33%6685.71%
ToSnakeCase(...)75%4483.33%
TryParseSourceKind(...)100%44100%
ToSnakeCase(...)100%44100%
TryParseRemoteType(...)100%8888.88%
ToSnakeCase(...)100%44100%
TryParseCultureLevel(...)80%111077.77%
ToSnakeCase(...)85.71%7790%
TryParseSignalType(...)81.81%222290.9%
ToSnakeCase(...)100%99100%
TryParseOwnershipType(...)96.87%323292.85%
ToSnakeCase(...)80%5587.5%
TryParseCompanyStatus(...)87.5%8888.88%
ToSnakeCase(...)75%4485.71%
TryParseFetchMethod(...)83.33%7675%
ToSnakeCase(...)75%4485.71%
TryParseCriterionCategory(...)75%11862.5%
ToSnakeCase(...)75%4483.33%
TryParseProvenanceKind(...)75%4471.42%
ToSnakeCase(...)75%4485.71%
TryParseResumeVariant(...)83.33%191887.5%
ToSnakeCase(...)75%4485.71%
TryParseApplicationOutcome(...)83.33%7675%
ToSnakeCase(...)90%101092.3%
TryParseApplicationEventType(...)82.35%343492.85%
ToSnakeCase(...)33.33%9655.55%
TryParseContactRelationship(...)0%156120%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Tracking/TrackingEnums.cs

#LineLine coverage
 1namespace RoleRadar.Domain.Tracking;
 2
 3public enum OwnershipType
 4{
 5    Public,
 6    Private,
 7    PeBacked,
 8    VcBacked,
 9    Mutual,
 10    Subsidiary,
 11    Nonprofit,
 12    Government,
 13    Unknown
 14}
 15
 16public enum CompanyStatus
 17{
 18    Target,
 19    Watch,
 20    Avoid,
 21    Neutral
 22}
 23
 24public enum CultureLevel
 25{
 26    Stable,
 27    Moderate,
 28    HighRisk,
 29    Unknown
 30}
 31
 32public enum PostingDisposition
 33{
 34    Lead,
 35    Scored,
 36    Applied,
 37    Rejected,
 38    ScreenedOut,
 39    Closed,
 40    Unscored
 41}
 42
 43public enum ResurfacePolicy
 44{
 45    Never,
 46    IfReopened
 47}
 48
 49public enum SourceKind
 50{
 51    Ats,
 52    Aggregator
 53}
 54
 55public enum RemoteType
 56{
 57    Remote,
 58    Hybrid,
 59    Onsite,
 60    Unknown
 61}
 62
 63public enum FetchMethod
 64{
 65    Api,
 66    Browser,
 67    Blocked
 68}
 69
 70public enum CriterionCategory
 71{
 72    HardSkip,
 73    Weight,
 74    Preference
 75}
 76
 77public enum ProvenanceKind
 78{
 79    Stated,
 80    Inferred
 81}
 82
 83public enum ResumeVariant
 84{
 85    Tailored,
 86    AsIs,
 87    IcFramed
 88}
 89
 90public enum ApplicationOutcome
 91{
 92    Applied,
 93    Rejected,
 94    Closed
 95}
 96
 97public enum ApplicationEventType
 98{
 99    Applied,
 100    FollowUp,
 101    Interview,
 102    Offer,
 103    OfferAccepted,
 104    OfferDeclined,
 105    Rejected,
 106    Withdrawn,
 107
 108    /// <summary>A remark or correction. Never a response, a rejection or an interview, and never a status change.</summ
 109    Note
 110}
 111
 112public enum SignalType
 113{
 114    Repost,
 115    NoSalary,
 116    ParallelPosting,
 117    Gone,
 118    Phantom,
 119    Deadline
 120}
 121
 122public enum ContactRelationship
 123{
 124    Recruiter,
 125    Referral,
 126    HiringManager,
 127    Peer,
 128    Redacted
 129}
 130
 131public static class TrackingEnumExtensions
 132{
 13646133    public static string ToSnakeCase(this PostingDisposition disposition) => disposition switch
 13646134    {
 10874135        PostingDisposition.Lead => "lead",
 158136        PostingDisposition.Unscored => "unscored",
 398137        PostingDisposition.Scored => "scored",
 1072138        PostingDisposition.Applied => "applied",
 418139        PostingDisposition.ScreenedOut => "screened_out",
 234140        PostingDisposition.Closed => "closed",
 492141        PostingDisposition.Rejected => "rejected",
 0142        _ => disposition.ToString().ToLowerInvariant()
 13646143    };
 144
 145    public static bool TryParseDisposition(string? val, out PostingDisposition disposition)
 146    {
 6566147        disposition = PostingDisposition.Lead;
 6566148        if (string.IsNullOrWhiteSpace(val))
 149        {
 0150            return false;
 151        }
 152
 6566153        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 154        switch (s)
 155        {
 10360156            case "lead": disposition = PostingDisposition.Lead; return true;
 112157            case "unscored": disposition = PostingDisposition.Unscored; return true;
 328158            case "scored": disposition = PostingDisposition.Scored; return true;
 956159            case "applied": disposition = PostingDisposition.Applied; return true;
 160            case "screened_out":
 516161            case "screenedout": disposition = PostingDisposition.ScreenedOut; return true;
 212162            case "closed": disposition = PostingDisposition.Closed; return true;
 636163            case "rejected": disposition = PostingDisposition.Rejected; return true;
 6164            default: return false;
 165        }
 166    }
 167
 12928168    public static string ToSnakeCase(this ResurfacePolicy policy) => policy switch
 12928169    {
 12868170        ResurfacePolicy.Never => "never",
 60171        ResurfacePolicy.IfReopened => "if_reopened",
 0172        _ => policy.ToString().ToLowerInvariant()
 12928173    };
 174
 175    public static bool TryParseResurfacePolicy(string? val, out ResurfacePolicy policy)
 176    {
 8798177        policy = ResurfacePolicy.Never;
 8798178        if (string.IsNullOrWhiteSpace(val))
 179        {
 3260180            return false;
 181        }
 182
 5538183        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 184        switch (s)
 185        {
 10992186            case "never": policy = ResurfacePolicy.Never; return true;
 187            case "if_reopened":
 80188            case "ifreopened": policy = ResurfacePolicy.IfReopened; return true;
 2189            default: return false;
 190        }
 191    }
 192
 2586193    public static string ToSnakeCase(this SourceKind kind) => kind switch
 2586194    {
 2468195        SourceKind.Ats => "ats",
 118196        SourceKind.Aggregator => "aggregator",
 0197        _ => kind.ToString().ToLowerInvariant()
 2586198    };
 199
 200    public static bool TryParseSourceKind(string? val, out SourceKind kind)
 201    {
 8902202        kind = SourceKind.Ats;
 8902203        if (string.IsNullOrWhiteSpace(val))
 204        {
 3216205            return false;
 206        }
 207
 5686208        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 209        switch (s)
 210        {
 10840211            case "ats": kind = SourceKind.Ats; return true;
 528212            case "aggregator": kind = SourceKind.Aggregator; return true;
 2213            default: return false;
 214        }
 215    }
 216
 12656217    public static string ToSnakeCase(this RemoteType remoteType) => remoteType switch
 12656218    {
 162219        RemoteType.Remote => "remote",
 4504220        RemoteType.Hybrid => "hybrid",
 88221        RemoteType.Onsite => "onsite",
 7902222        _ => "unknown"
 12656223    };
 224
 225    public static bool TryParseRemoteType(string? val, out RemoteType remoteType)
 226    {
 8804227        remoteType = RemoteType.Unknown;
 8804228        if (string.IsNullOrWhiteSpace(val))
 229        {
 3264230            return false;
 231        }
 232
 5540233        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 234        switch (s)
 235        {
 120236            case "remote": remoteType = RemoteType.Remote; return true;
 8616237            case "hybrid": remoteType = RemoteType.Hybrid; return true;
 60238            case "onsite": remoteType = RemoteType.Onsite; return true;
 2280239            case "unknown": remoteType = RemoteType.Unknown; return true;
 2240            default: return false;
 241        }
 242    }
 243
 7900244    public static string ToSnakeCase(this CultureLevel cultureLevel) => cultureLevel switch
 7900245    {
 24246        CultureLevel.Stable => "stable",
 12247        CultureLevel.Moderate => "moderate",
 2248        CultureLevel.HighRisk => "high_risk",
 7862249        _ => "unknown"
 7900250    };
 251
 252    public static bool TryParseCultureLevel(string? val, out CultureLevel cultureLevel)
 253    {
 8804254        cultureLevel = CultureLevel.Unknown;
 8804255        if (string.IsNullOrWhiteSpace(val))
 256        {
 3266257            return false;
 258        }
 259
 5538260        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 261        switch (s)
 262        {
 48263            case "stable": cultureLevel = CultureLevel.Stable; return true;
 24264            case "moderate": cultureLevel = CultureLevel.Moderate; return true;
 265            case "high_risk":
 8266            case "highrisk": cultureLevel = CultureLevel.HighRisk; return true;
 10992267            case "unknown": cultureLevel = CultureLevel.Unknown; return true;
 2268            default: return false;
 269        }
 270    }
 271
 168272    public static string ToSnakeCase(this SignalType signalType) => signalType switch
 168273    {
 36274        SignalType.Repost => "repost",
 20275        SignalType.NoSalary => "no_salary",
 28276        SignalType.ParallelPosting => "parallel_posting",
 28277        SignalType.Gone => "gone",
 20278        SignalType.Phantom => "phantom",
 36279        SignalType.Deadline => "deadline",
 0280        _ => signalType.ToString().ToLowerInvariant()
 168281    };
 282
 283    public static bool TryParseSignalType(string? val, out SignalType signalType)
 284    {
 210285        signalType = SignalType.Repost;
 210286        if (string.IsNullOrWhiteSpace(val))
 287        {
 0288            return false;
 289        }
 290
 210291        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 292        switch (s)
 293        {
 104294            case "repost": signalType = SignalType.Repost; return true;
 295            case "no_salary":
 40296            case "nosalary": signalType = SignalType.NoSalary; return true;
 297            case "parallel_posting":
 24298            case "parallelposting": signalType = SignalType.ParallelPosting; return true;
 104299            case "gone": signalType = SignalType.Gone; return true;
 44300            case "phantom": signalType = SignalType.Phantom; return true;
 88301            case "deadline": signalType = SignalType.Deadline; return true;
 8302            default: return false;
 303        }
 304    }
 305
 1440306    public static string ToSnakeCase(this OwnershipType ownershipType) => ownershipType switch
 1440307    {
 138308        OwnershipType.Public => "public",
 388309        OwnershipType.Private => "private",
 76310        OwnershipType.PeBacked => "pe_backed",
 76311        OwnershipType.VcBacked => "vc_backed",
 32312        OwnershipType.Mutual => "mutual",
 50313        OwnershipType.Subsidiary => "subsidiary",
 32314        OwnershipType.Nonprofit => "nonprofit",
 20315        OwnershipType.Government => "government",
 628316        _ => "unknown"
 1440317    };
 318
 319    public static bool TryParseOwnershipType(string? val, out OwnershipType type)
 320    {
 854321        type = OwnershipType.Unknown;
 854322        if (string.IsNullOrWhiteSpace(val))
 323        {
 0324            return false;
 325        }
 326
 854327        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 328        switch (s)
 329        {
 352330            case "public": type = OwnershipType.Public; return true;
 620331            case "private": type = OwnershipType.Private; return true;
 332            case "pe_backed":
 64333            case "pebacked": type = OwnershipType.PeBacked; return true;
 334            case "vc_backed":
 64335            case "vcbacked": type = OwnershipType.VcBacked; return true;
 16336            case "mutual": type = OwnershipType.Mutual; return true;
 44337            case "subsidiary": type = OwnershipType.Subsidiary; return true;
 16338            case "nonprofit": type = OwnershipType.Nonprofit; return true;
 4339            case "government": type = OwnershipType.Government; return true;
 524340            case "unknown": type = OwnershipType.Unknown; return true;
 2341            default: return false;
 342        }
 343    }
 344
 1332345    public static string ToSnakeCase(this CompanyStatus status) => status switch
 1332346    {
 416347        CompanyStatus.Target => "target",
 122348        CompanyStatus.Watch => "watch",
 60349        CompanyStatus.Avoid => "avoid",
 734350        CompanyStatus.Neutral => "neutral",
 0351        _ => status.ToString().ToLowerInvariant()
 1332352    };
 353
 354    public static bool TryParseCompanyStatus(string? val, out CompanyStatus status)
 355    {
 870356        status = CompanyStatus.Neutral;
 870357        if (string.IsNullOrWhiteSpace(val))
 358        {
 0359            return false;
 360        }
 361
 870362        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 363        switch (s)
 364        {
 840365            case "target": status = CompanyStatus.Target; return true;
 136366            case "watch": status = CompanyStatus.Watch; return true;
 64367            case "avoid": status = CompanyStatus.Avoid; return true;
 696368            case "neutral": status = CompanyStatus.Neutral; return true;
 2369            default: return false;
 370        }
 371    }
 372
 120373    public static string ToSnakeCase(this FetchMethod method) => method switch
 120374    {
 64375        FetchMethod.Api => "api",
 34376        FetchMethod.Browser => "browser",
 22377        FetchMethod.Blocked => "blocked",
 0378        _ => method.ToString().ToLowerInvariant()
 120379    };
 380
 381    public static bool TryParseFetchMethod(string? val, out FetchMethod method)
 382    {
 118383        method = FetchMethod.Api;
 118384        if (string.IsNullOrWhiteSpace(val))
 385        {
 0386            return false;
 387        }
 388
 118389        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 390        switch (s)
 391        {
 168392            case "api": method = FetchMethod.Api; return true;
 44393            case "browser": method = FetchMethod.Browser; return true;
 24394            case "blocked": method = FetchMethod.Blocked; return true;
 0395            default: return false;
 396        }
 397    }
 398
 150399    public static string ToSnakeCase(this CriterionCategory category) => category switch
 150400    {
 60401        CriterionCategory.HardSkip => "hard_skip",
 4402        CriterionCategory.Weight => "weight",
 86403        CriterionCategory.Preference => "preference",
 0404        _ => category.ToString().ToLowerInvariant()
 150405    };
 406
 407    public static bool TryParseCriterionCategory(string? val, out CriterionCategory category)
 408    {
 132409        category = CriterionCategory.HardSkip;
 132410        if (string.IsNullOrWhiteSpace(val))
 411        {
 0412            return false;
 413        }
 414
 132415        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 416        switch (s)
 417        {
 418            case "hard_skip":
 172419            case "hardskip": category = CriterionCategory.HardSkip; return true;
 12420            case "weight": category = CriterionCategory.Weight; return true;
 76421            case "preference": category = CriterionCategory.Preference; return true;
 2422            default: return false;
 423        }
 424    }
 425
 144426    public static string ToSnakeCase(this ProvenanceKind provenance) => provenance switch
 144427    {
 120428        ProvenanceKind.Stated => "stated",
 24429        ProvenanceKind.Inferred => "inferred",
 0430        _ => provenance.ToString().ToLowerInvariant()
 144431    };
 432
 433    public static bool TryParseProvenanceKind(string? val, out ProvenanceKind provenance)
 434    {
 128435        provenance = ProvenanceKind.Stated;
 128436        if (string.IsNullOrWhiteSpace(val))
 437        {
 0438            return false;
 439        }
 440
 128441        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 442        switch (s)
 443        {
 244444            case "stated": provenance = ProvenanceKind.Stated; return true;
 8445            case "inferred": provenance = ProvenanceKind.Inferred; return true;
 2446            default: return false;
 447        }
 448    }
 449
 2266450    public static string ToSnakeCase(this ResumeVariant variant) => variant switch
 2266451    {
 2244452        ResumeVariant.Tailored => "tailored",
 12453        ResumeVariant.AsIs => "as_is",
 10454        ResumeVariant.IcFramed => "ic_framed",
 0455        _ => variant.ToString().ToLowerInvariant()
 2266456    };
 457
 458    public static bool TryParseResumeVariant(string? val, out ResumeVariant variant)
 459    {
 544460        variant = ResumeVariant.Tailored;
 544461        if (string.IsNullOrWhiteSpace(val))
 462        {
 0463            return false;
 464        }
 465
 544466        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 467        switch (s)
 468        {
 1028469            case "tailored": variant = ResumeVariant.Tailored; return true;
 470            case "as_is":
 471            case "asis":
 472            case "not_tailored":
 24473            case "nottailored": variant = ResumeVariant.AsIs; return true;
 474            case "ic_framed":
 20475            case "icframed": variant = ResumeVariant.IcFramed; return true;
 8476            default: return false;
 477        }
 478    }
 479
 7488480    public static string ToSnakeCase(this ApplicationOutcome outcome) => outcome switch
 7488481    {
 6006482        ApplicationOutcome.Applied => "applied",
 1020483        ApplicationOutcome.Rejected => "rejected",
 462484        ApplicationOutcome.Closed => "closed",
 0485        _ => outcome.ToString().ToLowerInvariant()
 7488486    };
 487
 488    public static bool TryParseApplicationOutcome(string? val, out ApplicationOutcome outcome)
 489    {
 2912490        outcome = ApplicationOutcome.Applied;
 2912491        if (string.IsNullOrWhiteSpace(val))
 492        {
 0493            return false;
 494        }
 495
 2912496        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 497        switch (s)
 498        {
 4564499            case "applied": outcome = ApplicationOutcome.Applied; return true;
 856500            case "rejected": outcome = ApplicationOutcome.Rejected; return true;
 404501            case "closed": outcome = ApplicationOutcome.Closed; return true;
 0502            default: return false;
 503        }
 504    }
 505
 2810506    public static string ToSnakeCase(this ApplicationEventType eventType) => eventType switch
 2810507    {
 1198508        ApplicationEventType.Applied => "applied",
 144509        ApplicationEventType.FollowUp => "follow_up",
 518510        ApplicationEventType.Interview => "interview",
 176511        ApplicationEventType.Offer => "offer",
 68512        ApplicationEventType.OfferAccepted => "offer_accepted",
 68513        ApplicationEventType.OfferDeclined => "offer_declined",
 374514        ApplicationEventType.Rejected => "rejected",
 68515        ApplicationEventType.Withdrawn => "withdrawn",
 196516        ApplicationEventType.Note => "note",
 0517        _ => eventType.ToString().ToLowerInvariant()
 2810518    };
 519
 520    public static bool TryParseApplicationEventType(string? val, out ApplicationEventType eventType)
 521    {
 262522        eventType = ApplicationEventType.Applied;
 262523        if (string.IsNullOrWhiteSpace(val))
 524        {
 0525            return false;
 526        }
 527
 262528        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 529        switch (s)
 530        {
 176531            case "applied": eventType = ApplicationEventType.Applied; return true;
 532            case "follow_up":
 32533            case "followup": eventType = ApplicationEventType.FollowUp; return true;
 128534            case "interview": eventType = ApplicationEventType.Interview; return true;
 20535            case "offer": eventType = ApplicationEventType.Offer; return true;
 536            case "offer_accepted":
 20537            case "offeraccepted": eventType = ApplicationEventType.OfferAccepted; return true;
 538            case "offer_declined":
 20539            case "offerdeclined": eventType = ApplicationEventType.OfferDeclined; return true;
 68540            case "rejected": eventType = ApplicationEventType.Rejected; return true;
 20541            case "withdrawn": eventType = ApplicationEventType.Withdrawn; return true;
 36542            case "note": eventType = ApplicationEventType.Note; return true;
 2543            default: return false;
 544        }
 545    }
 546
 24547    public static string ToSnakeCase(this ContactRelationship relationship) => relationship switch
 24548    {
 0549        ContactRelationship.Recruiter => "recruiter",
 0550        ContactRelationship.Referral => "referral",
 0551        ContactRelationship.HiringManager => "hiring_manager",
 20552        ContactRelationship.Peer => "peer",
 4553        ContactRelationship.Redacted => "redacted",
 0554        _ => relationship.ToString().ToLowerInvariant()
 24555    };
 556
 557    public static bool TryParseContactRelationship(string? val, out ContactRelationship relationship)
 558    {
 0559        relationship = ContactRelationship.Recruiter;
 0560        if (string.IsNullOrWhiteSpace(val))
 561        {
 0562            return false;
 563        }
 564
 0565        var s = val.Trim().ToLowerInvariant().Replace("-", "_");
 566        switch (s)
 567        {
 0568            case "recruiter": relationship = ContactRelationship.Recruiter; return true;
 0569            case "referral": relationship = ContactRelationship.Referral; return true;
 570            case "hiring_manager":
 0571            case "hiringmanager": relationship = ContactRelationship.HiringManager; return true;
 0572            case "peer": relationship = ContactRelationship.Peer; return true;
 0573            case "redacted": relationship = ContactRelationship.Redacted; return true;
 0574            default: return false;
 575        }
 576    }
 577}

Methods/Properties

ToSnakeCase(RoleRadar.Domain.Tracking.PostingDisposition)
TryParseDisposition(System.String,RoleRadar.Domain.Tracking.PostingDisposition&)
ToSnakeCase(RoleRadar.Domain.Tracking.ResurfacePolicy)
TryParseResurfacePolicy(System.String,RoleRadar.Domain.Tracking.ResurfacePolicy&)
ToSnakeCase(RoleRadar.Domain.Tracking.SourceKind)
TryParseSourceKind(System.String,RoleRadar.Domain.Tracking.SourceKind&)
ToSnakeCase(RoleRadar.Domain.Tracking.RemoteType)
TryParseRemoteType(System.String,RoleRadar.Domain.Tracking.RemoteType&)
ToSnakeCase(RoleRadar.Domain.Tracking.CultureLevel)
TryParseCultureLevel(System.String,RoleRadar.Domain.Tracking.CultureLevel&)
ToSnakeCase(RoleRadar.Domain.Tracking.SignalType)
TryParseSignalType(System.String,RoleRadar.Domain.Tracking.SignalType&)
ToSnakeCase(RoleRadar.Domain.Tracking.OwnershipType)
TryParseOwnershipType(System.String,RoleRadar.Domain.Tracking.OwnershipType&)
ToSnakeCase(RoleRadar.Domain.Tracking.CompanyStatus)
TryParseCompanyStatus(System.String,RoleRadar.Domain.Tracking.CompanyStatus&)
ToSnakeCase(RoleRadar.Domain.Tracking.FetchMethod)
TryParseFetchMethod(System.String,RoleRadar.Domain.Tracking.FetchMethod&)
ToSnakeCase(RoleRadar.Domain.Tracking.CriterionCategory)
TryParseCriterionCategory(System.String,RoleRadar.Domain.Tracking.CriterionCategory&)
ToSnakeCase(RoleRadar.Domain.Tracking.ProvenanceKind)
TryParseProvenanceKind(System.String,RoleRadar.Domain.Tracking.ProvenanceKind&)
ToSnakeCase(RoleRadar.Domain.Tracking.ResumeVariant)
TryParseResumeVariant(System.String,RoleRadar.Domain.Tracking.ResumeVariant&)
ToSnakeCase(RoleRadar.Domain.Tracking.ApplicationOutcome)
TryParseApplicationOutcome(System.String,RoleRadar.Domain.Tracking.ApplicationOutcome&)
ToSnakeCase(RoleRadar.Domain.Tracking.ApplicationEventType)
TryParseApplicationEventType(System.String,RoleRadar.Domain.Tracking.ApplicationEventType&)
ToSnakeCase(RoleRadar.Domain.Tracking.ContactRelationship)
TryParseContactRelationship(System.String,RoleRadar.Domain.Tracking.ContactRelationship&)