Jag behöver bara några ord för att ge dig mitt svar på rubriken på denna artikel, det gör mitt liv enklare!

Varje gång jag hittar ett nytt problem som borde lösas inom finans och jag börjar drömma om en ny applikation som jag vill skapa använder jag alltid Bricknode som kärna. Den fyller rollen av att vara allt från en reskontra med flera transaktionsdimensioner till CRM till en generell databas där jag kan lagra alla mina entiteter som Custom Fields om jag vill.

Den är utbyggbar i oändlighet och jag kan bygga ut min egen funktionalitet för att expandera plattformen med extrem enkelhet. Med Custom Fields kan jag skapa min egen state hantering för händelser och med Webhooks kan jag komma bort från återkommande pull-operationer.

Det här är verkligen ett riktigt operativsystem för finansiella verksamheter där den enda begränsningen är din egen fantasi om vad du kan bygga.

I vår senaste version lade vi till en första generisk endpoint i vårt API där du kan arbeta med Custom Fields på vilken entitet som helst utan att använda den specifika endpointen för den entiteten. Detta var en fantastisk idé av vårt ingenjörsteam och vi följer upp detta genom att lägga till nya endpoints för att skapa och uppdatera Custom Fields i vår nästa release som jag ser fram emot.

Vänligen kontakta oss för att utforska hur du kan använda Bricknode som kärna för ditt nästa mjukvaruprojekt och minska din time to market avsevärt!

I sin kärna, är Bricknode Financial Systems som en databas applikation för att bygga finansiell mjukvara där du inte behöver drifta och underhålla databasen. Med Bricknodes API kan du i stort sett utveckla vilken finansiell tjänst du kan tänka dig utan att behöva uppfinna hjulet igen. Så kallade Custom Fields gör det möjligt för vem som helst att skräddarsy BFS och göra det till sitt eget genom att kunna spara vilken data som helst i relation till olika objekt. Några exempel hittar du här och här.

I denna artikel visade vi några exempel på hur Custom Fields kan användas.

Även på vår API site har vi en artikel om Custom Fields.

Vi tycker att detta är den enskilt mest användbara funktion som finns i BFS eftersom du kan expandera applikationens funktionalitet för att hantera saker som vi inte har tänkt på.

Tipsa oss gärna om hur du har använt Custom Fields om du vill dela med dig av det till vår community!

Läs gärna igenom hela guiden som beskriver hur vi expanderade BFS för att hantera fondtillgångar för att förstå kraften i denna funktion.

A neat new cost efficient way to build smaller functions that can be consumed through simple HttpRequests are Azure Functions. Instead of building and hosting a whole web application it is now possible to build a function that can be triggered through a HttpRequest and then perform a number of things.

Ideally when building some financial functions we don’t want to set up new databases to keep our data and thanks to the Custom Fields within Bricknode Financial Systems (”BFS”) we can just create new fields ad-hoc and keep our data in BFS.

In this example we wanted to build a function that took care of closing a share offering in BFS once a certain level of subscriptions for the offer had been reached.

To start with we used the UpdateInstruments function to create a custom field to hold the number of shares that would be the limit of the offer.

First we have a function to update the instrument with custom fields and the status of the instrument.

private static async Task<UpdateInstrumentResponse> UpdateInstrument(UpdateInstrument[] entities)
{
    return await Client.UpdateInstrumentsAsync(new UpdateInstrumentsRequest
    {
        Credentials = Credentials,
        identify = BfsIdentifier,
        Fields = new UpdateInstrumentFields
        {
            CustomFields = true,
            InstrumentStatus = true
        },
        Entities = entities
    });
}

Next, we will set the custom field to 1000 shares and we name the custom field ”ShareLimit”.

private static async Task CreateAndSetCustomField(Guid instrumentId)
{
    var response = await UpdateInstrument(new UpdateInstrument[]
    {
        new UpdateInstrument
        {
            BrickId = instrumentId,
            CustomFields = new CustomField[]
            {
                new CustomField
                {
                    FieldName = "ShareLimit",
                    Value = "1000"
                }
            }
        }
    });
}

Creating, updating and deleting custom fields can also be done fully in the GUI of BFS where each object supports a collection of custom fields.

In the Azure Function we can now calculate how many shares are subscribed for each time a new subscription is posted on our onboarding form which we can collect with the following function that use GetSubscriptionOrders.

private static async Task<GetSubscriptionOrderResponse> GetSubscriptionOrders(Guid instrumentId)
{
    return await Client.GetSubscriptionOrdersAsync(new GetSubscriptionOrderRequest
    {
        Credentials = Credentials,
        identify = BfsIdentifier,
        Args = new GetSubscriptionOrderArgs
        {
            BrickIds = new []{instrumentId},
            States = new[] {"Created"}
        },
        Fields = new GetSubscriptionOrderFields
        {
            BrickId = true,
            InstrumentAmount = true
        }
    });
}

private static async Task<decimal> CalculateSubscriptionVolume(Guid instrumentId)
{
    var response = await GetSubscriptionOrders(instrumentId);

    return response.Result.Sum(sum => sum.InstrumentAmount);
}

Now we need to compare the subscribed volume to the limit amount that we entered in the custom field.

First we need a function to get the instrument details.

private static async Task<GetInstrumentsResponse> GetInstrumentsById(Guid instrumentId)
{
    return await Client.GetInstrumentsAsync(new GetInstrumentsRequest()
    {
        Credentials = Credentials,
        identify = BfsIdentifier,
        Args = new GetInstrumentsArgs()
        {
            BrickIds = new Guid[] {instrumentId}
        },
        Fields = new GetInstrumentsFields()
        {
            BrickId = true,
            InstrumentType = true,
            Name = true,
            CustomFields = true
        }
    });
}
private static async Task EvaluateSubscriptionStatus(Guid instrumentId)
{
    var instrument = await GetInstrumentsById(instrumentId);

    var subscriptionVolumeLimit = Decimal.Parse(instrument.Result.First().CustomFields
        .First(t => t.FieldName == "ShareLimit").Value);

    var subscribedVolume = await CalculateSubscriptionVolume(instrumentId);

    if (subscribedVolume >= subscriptionVolumeLimit)
    {
        await CloseInstrument(instrumentId);
    }

}

Finally we can change the status of the instrument so that it is not open for further subscriptions by updating the status to Closed.

private static async Task CloseInstrument(Guid instrumentId)
{
    var response = await UpdateInstrument(new UpdateInstrument[]
    {
        new UpdateInstrument
        {
            BrickId = instrumentId,
            InstrumentStatus = 3
        }
    });
}