UUID in Batch Operations

Many users struggle with batch operations because, although UUIDs are straightforward to use, they are often unaware that they need to locate and use them when performing batch operations.

1. I suggest adding UUIDs as a column in listings such as the Customers tab, Purchase Invoices, and other relevant sections. This would allow users to export the UUIDs and, if they are proficient with spreadsheets, use lookup functions to prepare data for batch operations more easily.

2. I also suggest adding a brief note to the batch operation screen (for UUIDs and getting column header names right), at where users copy the existing data or paste data for processing. This would help educate users about the requirements for batch operations and clarify what is expected of them before they proceed.

image

Fixing UUID visibility can be easily done by showing it on the View screen instead of Edit, in larger font with legible contrast.

IMO, the biggest problem with batch operation is the use of additional columns for additional transaction lines along with how convoluted the process is.

  • This doesn’t align with how CSV files are usually formatted. Users would need to define a function in something like PowerQuery or use Python to transform the CSV file before the data can be used for batch operation
  • Because you have to include the same field (as a header) if even 1 line populates it, it’s not hard to exceed the column limit for Excel
  • It should be easier to grab the headers. Currently you have to do Batch Update, select at least 1 entry that has nothing to do with the transaction you want to create, then Copy to Clipboard, paste to spreadsheet before you can even see headers. Then you need to cancel Batch Update, select Batch Create before finally entering the data.

My suggestion is to introduce Batch Operation v2 as a dropdown:

  • Batch Create v2 should trigger a download of CSV file with all headers in row 1, sample data in row 2, instructions in row 3. This will fix the problem of header and how to use in one action.
  • Manager should do the row to column transform internally, instead of letting the user do it. So only Lines.1.* and Items.1.* headers. Users should only need to change the header in their source data to complete the mapping.

That’s a problem representing a hieratical or relational database in a flat database program such as a spreadsheet. There is no ideal solution to this problem.

Batch create generates a basic set of headings.

If a user really wants to understand it then the user should first create entries using the GUI / user data entry interface then use batch update to see how each entry translates to the internal database representation. A spreadsheet template can then be created with all the heading each user needs.

Getting manager to create all possible headings is not practical as Manager can handle records with a very large number of sub fields (lines in an invoice / payment / receipt)

I’m not suggesting there is solution to the representation problem, I’m simply suggesting that the process of dealing with the problem be made easier. If the user only has to deal with:

  • IssueDate
  • Reference
  • Customer
  • DueDateDays
  • Lines.1.Item
  • Lines.1.Qty
  • Liens.1.SalesUnitPrice
  • Lines.1.Division

repeated 100 times as multiple rows while Manager performs the row to column transformation in the background, it’s so much easier for the user compared to Lines.1.Item Lines.2.Item … Lines.100.Item

This increased complexity that’s forced on the user serves no real purpose IMO.

Again, I’m not suggesting that Manager spits out every single possible header.

  • When a user selects Batch Create while under the Purchase Invoice functional tab, it should only output the headers for Purchase Invoice. After all, there are only so many default headers for Purchase Invoice plus any Custom Fields the user enabled for Purchase Invoice.
  • When a user does Batch Create under Sales Invoice, they should naturally get the headers that apply to Sales Invoice

I don’t understand the value of having to go through multiple steps involving a different transaction type than the one you intend to perform just to get headers. Why not have a button under Batch Operations that says Export Default Headers so the user can get it in 1 action? It’s like saying because I walked 10 km to school everyday when I was young, my kid is lazy if he takes the bus.

Because it shows exactly what data goes where and in what format and with exactly what header.

After seen a working solution it is then easier to reproduce.

You do realise the columns can be in any order provided the headings are exactly correct. So Line.1 sub fields can be grouped in the spreadsheet (which is what I have always done). Then columns for line.2 fields etc. Missing columns resulting in null data entry.

That’s unless you want manager to put all similar entries as different lines on the same transaction. That would prevent batch creating 2 invoices for the same customer on any one day. So not a solution I would support.

Yes, I understand the order doesn’t matter.

My suggestion is simply that pasting the following into Manager should be sufficient when entering a multiple line or multiple invoice transaction:

You are suggesting that no, it’s not sufficient, the customer must apply the following PowerQuery themselves:

// Function: Unpivot all columns except the specified ones then perform row to column transformation for Manager.io batch operation
let
    Source = (tbl as table, columnsToKeep as list) as table =>
let
    Unpivoted = Table.UnpivotOtherColumns(
        tbl,
        columnsToKeep,
        "Attribute",  // Name of column for original column names
        "Value"       // Name of column for values
    ),
    #"Split Column by Delimiter" = Table.SplitColumn(Unpivoted, "Attribute", Splitter.SplitTextByDelimiter(".", QuoteStyle.Csv), {"Attribute.1", "Attribute.2", "Attribute.3"}),
    #"Removed Columns" = Table.RemoveColumns(#"Split Column by Delimiter",{"Attribute.2"}),
    #"Filtered Rows" = Table.SelectRows(#"Removed Columns", each ([Attribute.1] = "Lines")),
    //get group key
    groupkey = List.RemoveItems(Table.ColumnNames(#"Filtered Rows"), {"Value"}),
    //get the other columns
    ungroupedColumns = List.Difference(Table.ColumnNames(#"Filtered Rows"), groupkey),
    //group dynamically
    #"Grouped Rows" = Table.Group(
        #"Filtered Rows",
        groupkey,       
        {
            {"All", each _, type table}
        }
    ),
    #"Added Custom" = Table.AddColumn(#"Grouped Rows", "Custom", each Table.AddIndexColumn([All],"Index",1)),
    #"Removed Other Columns" = Table.SelectColumns(#"Added Custom", {"Custom"}),
    #"Expand Columns" = Table.Combine(#"Removed Other Columns"[Custom]),
    #"Sorted Rows" = Table.Sort(#"Expand Columns",{{"Index", Order.Ascending}}),
    #"Merged Columns" = Table.CombineColumns(Table.TransformColumnTypes(#"Sorted Rows", {
        {"Index", type text}}, "en-US"),
        {"Attribute.1", "Index", "Attribute.3"}
        ,Combiner.CombineTextByDelimiter(".", QuoteStyle.None), "Merged"),
    // remove all placeholders
    allColumnNames = Table.ColumnNames(#"Merged Columns"),
    replaceFn = each if _ = "PLACEHOLDER" then null else _,
    transformAll = List.Transform(allColumnNames, each {_, replaceFn}),    
    #"remove placeholders" = Table.TransformColumns(#"Merged Columns", transformAll),   
    #"Pivoted Column" = Table.Pivot(#"remove placeholders", List.Distinct(#"Merged Columns"[Merged]), "Merged", "Value")    
in 
    #"Pivoted Column"
in
    Source

to get:

image

before copy pasting into Manager

I simply do not see the value. Nor do I see the value in needing to extract the headers every time like it’s a chore.

Batch Operations is supposed to save time, making it complicated negates that.

Please see post by @Lubos in January 2024:

https://forum.manager.io/t/add-uuids-to-columns/50074/3

The latest version (24.1.7) improves batch operations so you can use codes or reference numbers instead of internal UUID keys when using Batch Update or Batch Create functions.

No one is suggesting anyone does that.

Batch create is a database communication standard between software packages.

Whoever is setting up the communication does it once. After which the headers are generated by the data generation software (spreadsheet or other software). While it is possible for the data source program to produce the data in one format then convert it to another, there would need to be a good reason to do it that way (as it requires code such as you describe).

Batch update can be useful for mass data edits. To do so reliably it is critical all data for each transaction is kept together. The one line record Manger uses ensures each field is specified exactly once, item lines are within the same record, item lines are kept in the desired order and item lines can be added or deleted as required.

So no I do not support an software communication standard that involves disassembly of a transactions at the source and reassembly at the destination.