@flarehr/superhero-basic-profile 0.1.2215 → 0.1.2217

package/dist/Basic.Profile.Domain/Import/Api/InternalApi/Write.jsx

@@ -0,0 +1,51 @@
+import { Record } from "../../../../fable_modules/fable-library-js.4.20.0/Types.js";
+import { list_type, int32_type, record_type, option_type, string_type } from "../../../../fable_modules/fable-library-js.4.20.0/Reflection.js";
+
+export class ImportProfileDataDto extends Record {
+    constructor(FirstName, MiddleName, LastName, Email, MobileNumber, ExternalId, Title, Gender, DateOfBirth, AddressLine1, AddressLine2, City, State, Postcode, CountryCode) {
+        super();
+        this.FirstName = FirstName;
+        this.MiddleName = MiddleName;
+        this.LastName = LastName;
+        this.Email = Email;
+        this.MobileNumber = MobileNumber;
+        this.ExternalId = ExternalId;
+        this.Title = Title;
+        this.Gender = Gender;
+        this.DateOfBirth = DateOfBirth;
+        this.AddressLine1 = AddressLine1;
+        this.AddressLine2 = AddressLine2;
+        this.City = City;
+        this.State = State;
+        this.Postcode = Postcode;
+        this.CountryCode = CountryCode;
+    }
+}
+
+export function ImportProfileDataDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.InternalApi.Write.ImportProfileDataDto", [], ImportProfileDataDto, () => [["FirstName", option_type(string_type)], ["MiddleName", option_type(string_type)], ["LastName", option_type(string_type)], ["Email", option_type(string_type)], ["MobileNumber", option_type(string_type)], ["ExternalId", option_type(string_type)], ["Title", option_type(string_type)], ["Gender", option_type(string_type)], ["DateOfBirth", option_type(string_type)], ["AddressLine1", option_type(string_type)], ["AddressLine2", option_type(string_type)], ["City", option_type(string_type)], ["State", option_type(string_type)], ["Postcode", option_type(string_type)], ["CountryCode", option_type(string_type)]]);
+}
+
+export class ImportRowDataDto extends Record {
+    constructor(RowId, Data) {
+        super();
+        this.RowId = (RowId | 0);
+        this.Data = Data;
+    }
+}
+
+export function ImportRowDataDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.InternalApi.Write.ImportRowDataDto", [], ImportRowDataDto, () => [["RowId", int32_type], ["Data", ImportProfileDataDto_$reflection()]]);
+}
+
+export class ImportDataDto extends Record {
+    constructor(Data) {
+        super();
+        this.Data = Data;
+    }
+}
+
+export function ImportDataDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.InternalApi.Write.ImportDataDto", [], ImportDataDto, () => [["Data", list_type(ImportRowDataDto_$reflection())]]);
+}
+

package/dist/Basic.Profile.Domain/Import/Api/Read.jsx

@@ -0,0 +1,154 @@
+import { Union, Record } from "../../../fable_modules/fable-library-js.4.20.0/Types.js";
+import { union_type, list_type, record_type, class_type, option_type, string_type, int32_type } from "../../../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { ActiveImportModule_importsRemaining, ImportIdModule_value } from "../Types.jsx";
+import { UtcDateTimeModule_value } from "../../DomainPrimitives.jsx";
+import { map as map_1, empty } from "../../../fable_modules/fable-library-js.4.20.0/List.js";
+import { map } from "../../../fable_modules/fable-library-js.4.20.0/Option.js";
+
+export class ActiveImportDto extends Record {
+    constructor(ImportId, User, Filename, NumberOfRecords, CompletedSuccessfully, CompletedFailed, NextRow, StartTime) {
+        super();
+        this.ImportId = (ImportId | 0);
+        this.User = User;
+        this.Filename = Filename;
+        this.NumberOfRecords = (NumberOfRecords | 0);
+        this.CompletedSuccessfully = (CompletedSuccessfully | 0);
+        this.CompletedFailed = (CompletedFailed | 0);
+        this.NextRow = NextRow;
+        this.StartTime = StartTime;
+    }
+}
+
+export function ActiveImportDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.ActiveImportDto", [], ActiveImportDto, () => [["ImportId", int32_type], ["User", string_type], ["Filename", string_type], ["NumberOfRecords", int32_type], ["CompletedSuccessfully", int32_type], ["CompletedFailed", int32_type], ["NextRow", option_type(int32_type)], ["StartTime", class_type("System.DateTime")]]);
+}
+
+export function ActiveImportDtoModule_ofDomain(domain) {
+    let matchValue;
+    return new ActiveImportDto(ImportIdModule_value(domain.ImportId), (matchValue = domain.Actor, (matchValue.tag === 1) ? "Apollo Import" : matchValue.fields[0].Name), domain.FileInfo.Filename, domain.NumberOfRecords, domain.CompletedSuccessfully, domain.CompletedFailed, domain.NextRow, UtcDateTimeModule_value(domain.StartTime));
+}
+
+export class ImportHistoryDto extends Record {
+    constructor(ImportId, User, Filename, NumberOfRecords, Succeeded, Failed, StartTime, StopTime) {
+        super();
+        this.ImportId = (ImportId | 0);
+        this.User = User;
+        this.Filename = Filename;
+        this.NumberOfRecords = (NumberOfRecords | 0);
+        this.Succeeded = (Succeeded | 0);
+        this.Failed = (Failed | 0);
+        this.StartTime = StartTime;
+        this.StopTime = StopTime;
+    }
+}
+
+export function ImportHistoryDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.ImportHistoryDto", [], ImportHistoryDto, () => [["ImportId", int32_type], ["User", string_type], ["Filename", string_type], ["NumberOfRecords", int32_type], ["Succeeded", int32_type], ["Failed", int32_type], ["StartTime", class_type("System.DateTime")], ["StopTime", class_type("System.DateTime")]]);
+}
+
+export function ImportHistoryDtoModule_ofDomain(domain) {
+    let matchValue;
+    return new ImportHistoryDto(ImportIdModule_value(domain.ImportId), (matchValue = domain.Actor, (matchValue.tag === 1) ? "Apollo Import" : matchValue.fields[0].Name), domain.FileInfo.Filename, domain.NumberOfRecords, domain.Succeeded, domain.Failed, UtcDateTimeModule_value(domain.StartTime), UtcDateTimeModule_value(domain.StopTime));
+}
+
+export class AccountImportsDto extends Record {
+    constructor(ActiveImport, ImportHistory) {
+        super();
+        this.ActiveImport = ActiveImport;
+        this.ImportHistory = ImportHistory;
+    }
+}
+
+export function AccountImportsDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.AccountImportsDto", [], AccountImportsDto, () => [["ActiveImport", option_type(ActiveImportDto_$reflection())], ["ImportHistory", list_type(ImportHistoryDto_$reflection())]]);
+}
+
+export const AccountImportsDtoModule_empty = new AccountImportsDto(undefined, empty());
+
+export function AccountImportsDtoModule_ofDomain(domain) {
+    return new AccountImportsDto(map(ActiveImportDtoModule_ofDomain, domain.ActiveImport), map_1(ImportHistoryDtoModule_ofDomain, domain.ImportHistory));
+}
+
+export class FieldError extends Record {
+    constructor(Column, Message) {
+        super();
+        this.Column = Column;
+        this.Message = Message;
+    }
+}
+
+export function FieldError_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.FieldError", [], FieldError, () => [["Column", string_type], ["Message", string_type]]);
+}
+
+export class RowValidationError extends Record {
+    constructor(RowId, FieldErrors) {
+        super();
+        this.RowId = (RowId | 0);
+        this.FieldErrors = FieldErrors;
+    }
+}
+
+export function RowValidationError_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.RowValidationError", [], RowValidationError, () => [["RowId", int32_type], ["FieldErrors", list_type(FieldError_$reflection())]]);
+}
+
+export class PostImportError extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["InvalidFileContentType", "InvalidFileName", "ExceedsMaxRows", "FileFormatError", "NoData", "NoFile", "MultipleFiles", "RowValidationErrors", "UnknownAccount", "ImportInProgress"];
+    }
+}
+
+export function PostImportError_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Api.Admin.Read.PostImportError", [], PostImportError, () => [[], [], [], [["Item", string_type]], [], [], [], [["Item", list_type(RowValidationError_$reflection())]], [], []]);
+}
+
+export class ImportDto extends Record {
+    constructor(ImportId, User, Filename, TotalRecordCount, SucceededRecordCount, FailedRecordCount, FailedRecords, RemainingRecordCount, StartTime, StopTime) {
+        super();
+        this.ImportId = (ImportId | 0);
+        this.User = User;
+        this.Filename = Filename;
+        this.TotalRecordCount = (TotalRecordCount | 0);
+        this.SucceededRecordCount = (SucceededRecordCount | 0);
+        this.FailedRecordCount = (FailedRecordCount | 0);
+        this.FailedRecords = FailedRecords;
+        this.RemainingRecordCount = (RemainingRecordCount | 0);
+        this.StartTime = StartTime;
+        this.StopTime = StopTime;
+    }
+}
+
+export function ImportDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.ImportDto", [], ImportDto, () => [["ImportId", int32_type], ["User", string_type], ["Filename", string_type], ["TotalRecordCount", int32_type], ["SucceededRecordCount", int32_type], ["FailedRecordCount", int32_type], ["FailedRecords", list_type(FailedImportRecordDto_$reflection())], ["RemainingRecordCount", int32_type], ["StartTime", class_type("System.DateTime")], ["StopTime", option_type(class_type("System.DateTime"))]]);
+}
+
+export class FailedImportRecordDto extends Record {
+    constructor(RowId, Reason) {
+        super();
+        this.RowId = (RowId | 0);
+        this.Reason = Reason;
+    }
+}
+
+export function FailedImportRecordDto_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Api.Admin.Read.FailedImportRecordDto", [], FailedImportRecordDto, () => [["RowId", int32_type], ["Reason", string_type]]);
+}
+
+export function ImportDtoModule_ofDomain(importStatus, rowFailures) {
+    let matchValue_1, matchValue;
+    if (importStatus.tag === 1) {
+        const historicalImport = importStatus.fields[0];
+        return new ImportDto(ImportIdModule_value(historicalImport.ImportId), (matchValue_1 = historicalImport.Actor, (matchValue_1.tag === 1) ? "Apollo Import" : matchValue_1.fields[0].Name), historicalImport.FileInfo.Filename, historicalImport.NumberOfRecords, historicalImport.Succeeded, historicalImport.Failed, map_1((tupledArg_1) => (new FailedImportRecordDto(tupledArg_1[0], tupledArg_1[1])), rowFailures), 0, UtcDateTimeModule_value(historicalImport.StartTime), UtcDateTimeModule_value(historicalImport.StopTime));
+    }
+    else {
+        const activeImport = importStatus.fields[0];
+        return new ImportDto(ImportIdModule_value(activeImport.ImportId), (matchValue = activeImport.Actor, (matchValue.tag === 1) ? "Apollo Import" : matchValue.fields[0].Name), activeImport.FileInfo.Filename, activeImport.NumberOfRecords, activeImport.CompletedSuccessfully, activeImport.CompletedFailed, map_1((tupledArg) => (new FailedImportRecordDto(tupledArg[0], tupledArg[1])), rowFailures), ActiveImportModule_importsRemaining(activeImport), UtcDateTimeModule_value(activeImport.StartTime), undefined);
+    }
+}
+

package/dist/Basic.Profile.Domain/Import/CommonTypes.jsx

@@ -0,0 +1,187 @@
+import { Record, Union } from "../../fable_modules/fable-library-js.4.20.0/Types.js";
+import { record_type, int32_type, string_type, union_type, class_type } from "../../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { newGuid, parse } from "../../fable_modules/fable-library-js.4.20.0/Guid.js";
+import { AppVersion_$reflection, StreamId_$reflection } from "../Metadata.jsx";
+import { AccountId_$reflection, PartnerId_$reflection, UtcDateTime_$reflection } from "../DomainPrimitives.jsx";
+import { CommandIdModule_value, CommandId_$reflection } from "../Commands.jsx";
+
+export class EventId extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["EventId"];
+    }
+}
+
+export function EventId_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.CommonTypes.EventId", [], EventId, () => [[["Item", class_type("System.Guid")]]]);
+}
+
+export function EventIdModule_create(eventId) {
+    return new EventId(parse(eventId));
+}
+
+export function EventIdModule_generate() {
+    return new EventId(newGuid());
+}
+
+export function EventIdModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export function EventIdModule_toString(eventId) {
+    let copyOfStruct;
+    return ((copyOfStruct = EventIdModule_value(eventId), copyOfStruct)).toLocaleUpperCase();
+}
+
+export class CausationId extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["CausationId"];
+    }
+}
+
+export function CausationId_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.CommonTypes.CausationId", [], CausationId, () => [[["Item", string_type]]]);
+}
+
+export function CausationIdModule_create(causationId) {
+    return new CausationId(causationId);
+}
+
+export function CausationIdModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export const $007CCausationId$007C = CausationIdModule_value;
+
+export class CorrelationId extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["CorrelationId"];
+    }
+}
+
+export function CorrelationId_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.CommonTypes.CorrelationId", [], CorrelationId, () => [[["Item", string_type]]]);
+}
+
+export function CorrelationIdModule_create(correlationId) {
+    return new CorrelationId(correlationId);
+}
+
+export function CorrelationIdModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export class EventMetadata$1 extends Record {
+    constructor(StreamId, Version, AppVersion, Timestamp, Domain) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.AppVersion = AppVersion;
+        this.Timestamp = Timestamp;
+        this.Domain = Domain;
+    }
+}
+
+export function EventMetadata$1_$reflection(gen0) {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.EventMetadata`1", [gen0], EventMetadata$1, () => [["StreamId", StreamId_$reflection()], ["Version", int32_type], ["AppVersion", AppVersion_$reflection()], ["Timestamp", UtcDateTime_$reflection()], ["Domain", gen0]]);
+}
+
+export class Event$2 extends Record {
+    constructor(Id, CausationId, CorrelationId, Payload, Metadata) {
+        super();
+        this.Id = Id;
+        this.CausationId = CausationId;
+        this.CorrelationId = CorrelationId;
+        this.Payload = Payload;
+        this.Metadata = Metadata;
+    }
+}
+
+export function Event$2_$reflection(gen0, gen1) {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.Event`2", [gen0, gen1], Event$2, () => [["Id", EventId_$reflection()], ["CausationId", CausationId_$reflection()], ["CorrelationId", CorrelationId_$reflection()], ["Payload", gen0], ["Metadata", EventMetadata$1_$reflection(gen1)]]);
+}
+
+export class AggregateMetadata$1 extends Record {
+    constructor(StreamId, Version, CreatedAt, UpdatedAt, Domain) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.CreatedAt = CreatedAt;
+        this.UpdatedAt = UpdatedAt;
+        this.Domain = Domain;
+    }
+}
+
+export function AggregateMetadata$1_$reflection(gen0) {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.AggregateMetadata`1", [gen0], AggregateMetadata$1, () => [["StreamId", StreamId_$reflection()], ["Version", int32_type], ["CreatedAt", UtcDateTime_$reflection()], ["UpdatedAt", UtcDateTime_$reflection()], ["Domain", gen0]]);
+}
+
+export function AggregateMetadata_incrementVersion(metadata, timestamp) {
+    return new AggregateMetadata$1(metadata.StreamId, metadata.Version + 1, metadata.CreatedAt, timestamp, metadata.Domain);
+}
+
+export class Aggregate$2 extends Record {
+    constructor(Data, Metadata) {
+        super();
+        this.Data = Data;
+        this.Metadata = Metadata;
+    }
+}
+
+export function Aggregate$2_$reflection(gen0, gen1) {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.Aggregate`2", [gen0, gen1], Aggregate$2, () => [["Data", gen0], ["Metadata", AggregateMetadata$1_$reflection(gen1)]]);
+}
+
+export function ErrorMessageModule_startsWith(prefix, errorMessage) {
+    return errorMessage.indexOf(prefix) === 0;
+}
+
+export class CommandMetadata extends Record {
+    constructor(PartnerId, AccountId, StreamId, Version, AppVersion, Timestamp) {
+        super();
+        this.PartnerId = PartnerId;
+        this.AccountId = AccountId;
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.AppVersion = AppVersion;
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function CommandMetadata_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.CommandMetadata", [], CommandMetadata, () => [["PartnerId", PartnerId_$reflection()], ["AccountId", AccountId_$reflection()], ["StreamId", StreamId_$reflection()], ["Version", int32_type], ["AppVersion", AppVersion_$reflection()], ["Timestamp", UtcDateTime_$reflection()]]);
+}
+
+export class Command$1 extends Record {
+    constructor(Id, CausationId, CorrelationId, Payload, Metadata) {
+        super();
+        this.Id = Id;
+        this.CausationId = CausationId;
+        this.CorrelationId = CorrelationId;
+        this.Payload = Payload;
+        this.Metadata = Metadata;
+    }
+}
+
+export function Command$1_$reflection(gen0) {
+    return record_type("Basic.Profile.Domain.Import.CommonTypes.Command`1", [gen0], Command$1, () => [["Id", CommandId_$reflection()], ["CausationId", CausationId_$reflection()], ["CorrelationId", CorrelationId_$reflection()], ["Payload", gen0], ["Metadata", CommandMetadata_$reflection()]]);
+}
+
+export function Command_toEvent(domainMetadata, currentVersion, command, eventPayload) {
+    return new Event$2(EventIdModule_generate(), CausationIdModule_create(CommandIdModule_value(command.Id)), command.CorrelationId, eventPayload, new EventMetadata$1(command.Metadata.StreamId, currentVersion + 1, command.Metadata.AppVersion, command.Metadata.Timestamp, domainMetadata));
+}
+