@flarehr/superhero-basic-profile 0.1.2214 → 0.1.2217

package/dist/Basic.Profile.Domain/Dto/Primitives.jsx

@@ -0,0 +1,580 @@
+import { PartnerIdModule_value, AccountIdModule_value, ProfileIdModule_value, ProfileId as ProfileId_1, RelationshipModule_ofDomain, FullNameModule_ofDomain, EmergencyContact, RelationshipModule_toDomain, FullNameModule_toDomain, PurgedAddress as PurgedAddress_1, Address as Address_1, DateOfBirth, MobilePhone, Email, Title, Gender, Name as Name_1, ExternalId, PartnerId, AccountId } from "../DomainPrimitives.jsx";
+import { compare, printf, toText, isNullOrWhiteSpace } from "../../fable_modules/fable-library-js.4.20.0/String.js";
+import { FSharpResult$2 } from "../../fable_modules/fable-library-js.4.20.0/Result.js";
+import { Union, Record } from "../../fable_modules/fable-library-js.4.20.0/Types.js";
+import { class_type, int32_type, anonRecord_type, union_type, record_type, option_type, string_type } from "../../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { requireEmail, requireNonEmpty } from "../Utils.jsx";
+import { Metadata as Metadata_1, ProfileEventMetadata, StreamId, DomainMetadata, AdminNameModule_value, AdminName, Source, SelfOperationType, AdminOperationType, InternalOperationType } from "../Metadata.jsx";
+
+export function AccountId_toDomain(Item) {
+    return new AccountId(Item);
+}
+
+export function AccountId_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export function PartnerId_toDomain(Item) {
+    return new PartnerId(Item);
+}
+
+export function PartnerId_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export function ExternalId_toDomain(value) {
+    if (isNullOrWhiteSpace(value)) {
+        return new FSharpResult$2(1, ["ExternalId cannot be an empty string"]);
+    }
+    else {
+        return new FSharpResult$2(0, [new ExternalId(value)]);
+    }
+}
+
+export function ExternalId_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export class Name extends Record {
+    constructor(FirstName, MiddleName, LastName) {
+        super();
+        this.FirstName = FirstName;
+        this.MiddleName = MiddleName;
+        this.LastName = LastName;
+    }
+}
+
+export function Name_$reflection() {
+    return record_type("Dto.Primitives.Name", [], Name, () => [["FirstName", string_type], ["MiddleName", option_type(string_type)], ["LastName", string_type]]);
+}
+
+export function NameModule_toDomain(name) {
+    const input_2 = requireNonEmpty("FirstName", name.FirstName);
+    if (input_2.tag === 1) {
+        return new FSharpResult$2(1, [input_2.fields[0]]);
+    }
+    else {
+        const input = requireNonEmpty("LastName", name.LastName);
+        if (input.tag === 1) {
+            return new FSharpResult$2(1, [input.fields[0]]);
+        }
+        else {
+            return new FSharpResult$2(0, [new Name_1(input_2.fields[0], name.MiddleName, input.fields[0])]);
+        }
+    }
+}
+
+export function NameModule_ofDomain(name) {
+    return new Name(name.FirstName, name.MiddleName, name.LastName);
+}
+
+export function Gender_toDomain(gender) {
+    switch (gender) {
+        case "Male":
+            return new FSharpResult$2(0, [new Gender(0, [])]);
+        case "Female":
+            return new FSharpResult$2(0, [new Gender(1, [])]);
+        case "Intersex":
+            return new FSharpResult$2(0, [new Gender(2, [])]);
+        case "Transgender":
+            return new FSharpResult$2(0, [new Gender(3, [])]);
+        case "PreferNotToAnswer":
+            return new FSharpResult$2(0, [new Gender(4, [])]);
+        case "Other":
+            return new FSharpResult$2(0, [new Gender(5, [])]);
+        case "NotSet":
+            return new FSharpResult$2(0, [new Gender(6, [])]);
+        default:
+            return new FSharpResult$2(1, [toText(printf("Gender %s not supported"))(gender)]);
+    }
+}
+
+export function Gender_ofDomain(gender) {
+    switch (gender.tag) {
+        case 1:
+            return "Female";
+        case 2:
+            return "Intersex";
+        case 3:
+            return "Transgender";
+        case 4:
+            return "PreferNotToAnswer";
+        case 5:
+            return "Other";
+        case 6:
+            return "NotSet";
+        default:
+            return "Male";
+    }
+}
+
+export function Title_toDomain(title) {
+    const input_1 = requireNonEmpty("Title", title);
+    if (input_1.tag === 1) {
+        return new FSharpResult$2(1, [input_1.fields[0]]);
+    }
+    else {
+        return new FSharpResult$2(0, [new Title(input_1.fields[0])]);
+    }
+}
+
+export function Title_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export function Email_toDomain(email) {
+    let input_3;
+    const input_1 = requireNonEmpty("Email", email);
+    input_3 = ((input_1.tag === 1) ? (new FSharpResult$2(1, [input_1.fields[0]])) : requireEmail(input_1.fields[0]));
+    if (input_3.tag === 1) {
+        return new FSharpResult$2(1, [input_3.fields[0]]);
+    }
+    else {
+        return new FSharpResult$2(0, [new Email(input_3.fields[0])]);
+    }
+}
+
+export function Email_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export function Email_areEqual(emailOne, emailTwo) {
+    return compare(Email_ofDomain(emailOne), Email_ofDomain(emailTwo), 5) === 0;
+}
+
+export function MobilePhone_toDomain(mobilePhone) {
+    const input_1 = requireNonEmpty("MobilePhone", mobilePhone);
+    if (input_1.tag === 1) {
+        return new FSharpResult$2(1, [input_1.fields[0]]);
+    }
+    else {
+        return new FSharpResult$2(0, [new MobilePhone(input_1.fields[0])]);
+    }
+}
+
+export function MobilePhone_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export function DateOfBirth_toDomain(dateOfBirth) {
+    const input_1 = requireNonEmpty("DateOfBirth", dateOfBirth);
+    if (input_1.tag === 1) {
+        return new FSharpResult$2(1, [input_1.fields[0]]);
+    }
+    else {
+        return new FSharpResult$2(0, [new DateOfBirth(input_1.fields[0])]);
+    }
+}
+
+export function DateOfBirth_ofDomain(_arg) {
+    return _arg.fields[0];
+}
+
+export class Address extends Record {
+    constructor(AddressLine1, AddressLine2, City, State, Postcode, CountryCode) {
+        super();
+        this.AddressLine1 = AddressLine1;
+        this.AddressLine2 = AddressLine2;
+        this.City = City;
+        this.State = State;
+        this.Postcode = Postcode;
+        this.CountryCode = CountryCode;
+    }
+}
+
+export function Address_$reflection() {
+    return record_type("Dto.Primitives.Address", [], Address, () => [["AddressLine1", string_type], ["AddressLine2", option_type(string_type)], ["City", string_type], ["State", string_type], ["Postcode", string_type], ["CountryCode", string_type]]);
+}
+
+export function AddressModule_toDomain(address) {
+    const input_8 = requireNonEmpty("AddressLine1", address.AddressLine1);
+    if (input_8.tag === 1) {
+        return new FSharpResult$2(1, [input_8.fields[0]]);
+    }
+    else {
+        const input_6 = requireNonEmpty("City", address.City);
+        if (input_6.tag === 1) {
+            return new FSharpResult$2(1, [input_6.fields[0]]);
+        }
+        else {
+            const input_4 = requireNonEmpty("State", address.State);
+            if (input_4.tag === 1) {
+                return new FSharpResult$2(1, [input_4.fields[0]]);
+            }
+            else {
+                const input_2 = requireNonEmpty("Postcode", address.Postcode);
+                if (input_2.tag === 1) {
+                    return new FSharpResult$2(1, [input_2.fields[0]]);
+                }
+                else {
+                    const input = requireNonEmpty("CountryCode", address.CountryCode);
+                    if (input.tag === 1) {
+                        return new FSharpResult$2(1, [input.fields[0]]);
+                    }
+                    else {
+                        return new FSharpResult$2(0, [new Address_1(input_8.fields[0], address.AddressLine2, input_6.fields[0], input_4.fields[0], input_2.fields[0], input.fields[0])]);
+                    }
+                }
+            }
+        }
+    }
+}
+
+export function AddressModule_ofDomain(address) {
+    return new Address(address.AddressLine1, address.AddressLine2, address.City, address.State, address.Postcode, address.CountryCode);
+}
+
+export class PurgedAddress extends Record {
+    constructor(City, State, Postcode, CountryCode) {
+        super();
+        this.City = City;
+        this.State = State;
+        this.Postcode = Postcode;
+        this.CountryCode = CountryCode;
+    }
+}
+
+export function PurgedAddress_$reflection() {
+    return record_type("Dto.Primitives.PurgedAddress", [], PurgedAddress, () => [["City", string_type], ["State", string_type], ["Postcode", string_type], ["CountryCode", string_type]]);
+}
+
+export function PurgedAddressModule_toDomain(address) {
+    const input_6 = requireNonEmpty("City", address.City);
+    if (input_6.tag === 1) {
+        return new FSharpResult$2(1, [input_6.fields[0]]);
+    }
+    else {
+        const input_4 = requireNonEmpty("State", address.State);
+        if (input_4.tag === 1) {
+            return new FSharpResult$2(1, [input_4.fields[0]]);
+        }
+        else {
+            const input_2 = requireNonEmpty("Postcode", address.Postcode);
+            if (input_2.tag === 1) {
+                return new FSharpResult$2(1, [input_2.fields[0]]);
+            }
+            else {
+                const input = requireNonEmpty("CountryCode", address.CountryCode);
+                if (input.tag === 1) {
+                    return new FSharpResult$2(1, [input.fields[0]]);
+                }
+                else {
+                    return new FSharpResult$2(0, [new PurgedAddress_1(input_6.fields[0], input_4.fields[0], input_2.fields[0], input.fields[0])]);
+                }
+            }
+        }
+    }
+}
+
+export function PurgedAddressModule_ofDomain(address) {
+    return new PurgedAddress(address.City, address.State, address.Postcode, address.CountryCode);
+}
+
+export class EmergencyContactDto extends Record {
+    constructor(FullName, Relationship, MobilePhone, Email, Address) {
+        super();
+        this.FullName = FullName;
+        this.Relationship = Relationship;
+        this.MobilePhone = MobilePhone;
+        this.Email = Email;
+        this.Address = Address;
+    }
+}
+
+export function EmergencyContactDto_$reflection() {
+    return record_type("Dto.Primitives.EmergencyContactDto", [], EmergencyContactDto, () => [["FullName", string_type], ["Relationship", string_type], ["MobilePhone", string_type], ["Email", option_type(string_type)], ["Address", option_type(Address_$reflection())]]);
+}
+
+export function EmergencyContactDtoModule_toDomain(contact) {
+    const input_14 = FullNameModule_toDomain(contact.FullName);
+    if (input_14.tag === 1) {
+        return new FSharpResult$2(1, [input_14.fields[0]]);
+    }
+    else {
+        const input_12 = RelationshipModule_toDomain(contact.Relationship);
+        if (input_12.tag === 1) {
+            return new FSharpResult$2(1, [input_12.fields[0]]);
+        }
+        else {
+            const input_10 = MobilePhone_toDomain(contact.MobilePhone);
+            if (input_10.tag === 1) {
+                return new FSharpResult$2(1, [input_10.fields[0]]);
+            }
+            else {
+                let input_8;
+                const input_1 = contact.Email;
+                if (input_1 != null) {
+                    const input_2 = Email_toDomain(input_1);
+                    input_8 = ((input_2.tag === 1) ? (new FSharpResult$2(1, [input_2.fields[0]])) : (new FSharpResult$2(0, [input_2.fields[0]])));
+                }
+                else {
+                    input_8 = (new FSharpResult$2(0, [undefined]));
+                }
+                if (input_8.tag === 1) {
+                    return new FSharpResult$2(1, [input_8.fields[0]]);
+                }
+                else {
+                    let input_6;
+                    const input_4 = contact.Address;
+                    if (input_4 != null) {
+                        const input_5 = AddressModule_toDomain(input_4);
+                        input_6 = ((input_5.tag === 1) ? (new FSharpResult$2(1, [input_5.fields[0]])) : (new FSharpResult$2(0, [input_5.fields[0]])));
+                    }
+                    else {
+                        input_6 = (new FSharpResult$2(0, [undefined]));
+                    }
+                    if (input_6.tag === 1) {
+                        return new FSharpResult$2(1, [input_6.fields[0]]);
+                    }
+                    else {
+                        return new FSharpResult$2(0, [new EmergencyContact(input_14.fields[0], input_12.fields[0], input_10.fields[0], input_8.fields[0], input_6.fields[0])]);
+                    }
+                }
+            }
+        }
+    }
+}
+
+export function EmergencyContactDtoModule_ofDomain(contact) {
+    let input_1, input_3;
+    return new EmergencyContactDto(FullNameModule_ofDomain(contact.FullName), RelationshipModule_ofDomain(contact.Relationship), MobilePhone_ofDomain(contact.MobilePhone), (input_1 = contact.Email, (input_1 == null) ? undefined : Email_ofDomain(input_1)), (input_3 = contact.Address, (input_3 == null) ? undefined : AddressModule_ofDomain(input_3)));
+}
+
+export class UnusedDto extends Record {
+    constructor(Unused) {
+        super();
+        this.Unused = Unused;
+    }
+}
+
+export function UnusedDto_$reflection() {
+    return record_type("Dto.Primitives.UnusedDto", [], UnusedDto, () => [["Unused", option_type(string_type)]]);
+}
+
+export const UnusedDtoModule_Default = new UnusedDto(undefined);
+
+export class InternalOperationTypeDto extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["MessageQueue", "Unused"];
+    }
+}
+
+export function InternalOperationTypeDto_$reflection() {
+    return union_type("Dto.Primitives.InternalOperationTypeDto", [], InternalOperationTypeDto, () => [[["Item", UnusedDto_$reflection()]], [["Item", UnusedDto_$reflection()]]]);
+}
+
+export function InternalOperationTypeDtoModule_toDomain(dto) {
+    if (dto.tag === 1) {
+        return new InternalOperationType();
+    }
+    else {
+        return new InternalOperationType();
+    }
+}
+
+export function InternalOperationTypeDtoModule_ofDomain(internalOperationType) {
+    return new InternalOperationTypeDto(0, [UnusedDtoModule_Default]);
+}
+
+export class AdminOperationTypeDto extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Direct", "Bulk"];
+    }
+}
+
+export function AdminOperationTypeDto_$reflection() {
+    return union_type("Dto.Primitives.AdminOperationTypeDto", [], AdminOperationTypeDto, () => [[["Item", UnusedDto_$reflection()]], [["Item", UnusedDto_$reflection()]]]);
+}
+
+export function AdminOperationTypeDtoModule_toDomain(dto) {
+    if (dto.tag === 1) {
+        return new AdminOperationType(1, []);
+    }
+    else {
+        return new AdminOperationType(0, []);
+    }
+}
+
+export function AdminOperationTypeDtoModule_ofDomain(adminOperationType) {
+    if (adminOperationType.tag === 1) {
+        return new AdminOperationTypeDto(1, [UnusedDtoModule_Default]);
+    }
+    else {
+        return new AdminOperationTypeDto(0, [UnusedDtoModule_Default]);
+    }
+}
+
+export class SelfOperationTypeDto extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Workflow", "Unused"];
+    }
+}
+
+export function SelfOperationTypeDto_$reflection() {
+    return union_type("Dto.Primitives.SelfOperationTypeDto", [], SelfOperationTypeDto, () => [[["Item", UnusedDto_$reflection()]], [["Item", UnusedDto_$reflection()]]]);
+}
+
+export function SelfOperationTypeDtoModule_toDomain(dto) {
+    if (dto.tag === 1) {
+        return new SelfOperationType();
+    }
+    else {
+        return new SelfOperationType();
+    }
+}
+
+export function SelfOperationTypeDtoModule_ofDomain(selfOperationType) {
+    return new SelfOperationTypeDto(0, [UnusedDtoModule_Default]);
+}
+
+export class SourceDto extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["ExternalApi", "InternalApi", "Self", "FlareAdmin", "SuperheroAdmin", "InternalOperation"];
+    }
+}
+
+export function SourceDto_$reflection() {
+    return union_type("Dto.Primitives.SourceDto", [], SourceDto, () => [[["Item", UnusedDto_$reflection()]], [["Item", UnusedDto_$reflection()]], [["Item", SelfOperationTypeDto_$reflection()]], [["Item", anonRecord_type(["Operation", AdminOperationTypeDto_$reflection()], ["ProfileId", string_type])]], [["Item", anonRecord_type(["AdminName", string_type], ["Email", string_type])]], [["Item", InternalOperationTypeDto_$reflection()]]]);
+}
+
+export function SourceDtoModule_toDomain(sourceDto) {
+    switch (sourceDto.tag) {
+        case 1:
+            return new Source(1, []);
+        case 2:
+            return new Source(2, [SelfOperationTypeDtoModule_toDomain(sourceDto.fields[0])]);
+        case 3: {
+            const adminDetails = sourceDto.fields[0];
+            return new Source(3, [{
+                Operation: AdminOperationTypeDtoModule_toDomain(adminDetails.Operation),
+                ProfileId: new ProfileId_1(adminDetails.ProfileId),
+            }]);
+        }
+        case 4: {
+            const details = sourceDto.fields[0];
+            return new Source(4, [{
+                AdminName: new AdminName(details.AdminName),
+                Email: new Email(details.Email),
+            }]);
+        }
+        case 5:
+            return new Source(5, [InternalOperationTypeDtoModule_toDomain(sourceDto.fields[0])]);
+        default:
+            return new Source(0, []);
+    }
+}
+
+export function SourceDtoModule_ofDomain(source) {
+    let ProfileId;
+    switch (source.tag) {
+        case 1:
+            return new SourceDto(1, [UnusedDtoModule_Default]);
+        case 2:
+            return new SourceDto(2, [SelfOperationTypeDtoModule_ofDomain(source.fields[0])]);
+        case 3: {
+            const adminDetails = source.fields[0];
+            return new SourceDto(3, [(ProfileId = ProfileIdModule_value(adminDetails.ProfileId), {
+                Operation: AdminOperationTypeDtoModule_ofDomain(adminDetails.Operation),
+                ProfileId: ProfileId,
+            })]);
+        }
+        case 4: {
+            const details = source.fields[0];
+            return new SourceDto(4, [{
+                AdminName: AdminNameModule_value(details.AdminName),
+                Email: Email_ofDomain(details.Email),
+            }]);
+        }
+        case 5:
+            return new SourceDto(5, [InternalOperationTypeDtoModule_ofDomain(source.fields[0])]);
+        default:
+            return new SourceDto(0, [UnusedDtoModule_Default]);
+    }
+}
+
+export class Metadata extends Record {
+    constructor(StreamId, Version, Timestamp) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function Metadata_$reflection() {
+    return record_type("Dto.Primitives.Metadata", [], Metadata, () => [["StreamId", string_type], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")]]);
+}
+
+export class DomainMetadataDto extends Record {
+    constructor(AccountId, PartnerId, Source) {
+        super();
+        this.AccountId = AccountId;
+        this.PartnerId = PartnerId;
+        this.Source = Source;
+    }
+}
+
+export function DomainMetadataDto_$reflection() {
+    return record_type("Dto.Primitives.DomainMetadataDto", [], DomainMetadataDto, () => [["AccountId", string_type], ["PartnerId", string_type], ["Source", SourceDto_$reflection()]]);
+}
+
+export function DomainMetadataDtoModule_toDomain(domainMetadataDto) {
+    return new DomainMetadata(new AccountId(domainMetadataDto.AccountId), new PartnerId(domainMetadataDto.PartnerId), SourceDtoModule_toDomain(domainMetadataDto.Source));
+}
+
+export function DomainMetadataDtoModule_ofDomain(domainMetadata) {
+    return new DomainMetadataDto(AccountIdModule_value(domainMetadata.AccountId), PartnerIdModule_value(domainMetadata.PartnerId), SourceDtoModule_ofDomain(domainMetadata.Source));
+}
+
+export class ProfileEventMetadataDto extends Record {
+    constructor(StreamId, Version, Timestamp, Domain) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.Timestamp = Timestamp;
+        this.Domain = Domain;
+    }
+}
+
+export function ProfileEventMetadataDto_$reflection() {
+    return record_type("Dto.Primitives.ProfileEventMetadataDto", [], ProfileEventMetadataDto, () => [["StreamId", string_type], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")], ["Domain", option_type(DomainMetadataDto_$reflection())]]);
+}
+
+export function ProfileEventMetadataDtoModule_toDomain(metadataDto) {
+    let input_1;
+    return new ProfileEventMetadata(new StreamId(metadataDto.StreamId), metadataDto.Version, metadataDto.Timestamp, (input_1 = metadataDto.Domain, (input_1 == null) ? undefined : DomainMetadataDtoModule_toDomain(input_1)));
+}
+
+export function ProfileEventMetadataDtoModule_ofDomain(metadata) {
+    let input_1;
+    return new ProfileEventMetadataDto(metadata.StreamId.fields[0], metadata.Version, metadata.Timestamp, (input_1 = metadata.Domain, (input_1 == null) ? undefined : DomainMetadataDtoModule_ofDomain(input_1)));
+}
+
+export function MetadataModule_toDomain(metadata) {
+    return new Metadata_1(new StreamId(metadata.StreamId), metadata.Version, metadata.Timestamp);
+}
+
+export function MetadataModule_ofDomain(metadata) {
+    return new Metadata(metadata.StreamId.fields[0], metadata.Version, metadata.Timestamp);
+}
+