How to open windows desktop applications from Acumatica

Imagine you are working on Acumatica customization that needs to integrate with an existing desktop application. How can you launch the desktop application from the web-based app? It might seem impossible at first, but on Windows, it's actually quite simple. The key is to use Custom Protocol Handlers. All you need to do is install a new custom protocol and tell Windows which application should handle it. For example, let's say you have a desktop application that performs sales analysis based on the stock item when it is launched. You can create a new custom protocol called " ItemAnalyzer://" and whenever a URL with this protocol is entered into the browser, the desktop application will be launched and the text after the protocol will be treated as a parameter.

 

It's important to note that when using protocol handlers, the protocol name itself will be included as part of the argument passed to the desktop application. This may require some additional processing to remove the protocol name (such as the "GetStringBetweenDelimiters" function on line 17). For example, if you run the desktop application with an argument, you might get something like the following:

class Program
{
    static void Main(string[] args)
    {
        string inventoryCD = GetStringBetweenDelimiters(args[0]);
 
        Console.WriteLine($"Processing...: {inventoryCD}");
        // ...
        // do something with inventoryCD
        // ...
 
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
 
    static string GetStringBetweenDelimiters(string input)
    {
        int firstIndex = input.IndexOf("://") + 3;
        int lastIndex = input.IndexOf('/', firstIndex);
        return input.Substring(firstIndex, lastIndex - firstIndex);
    }
 
    static void RegProtocol()
    {
        var key = Registry.ClassesRoot.CreateSubKey("ItemAnalyzer");
        
        key.SetValue("""URL:ItemAnalyzer Protocol");
        key.SetValue("URL Protocol""");
        
        var subKey = key.CreateSubKey(@"shell\open\command");
        var execPath = Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location),
                                    System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName);
 
        subKey.SetValue(""$"{execPath} %1");
        subKey.Close();
        key.Close();
    }
}

 

To make the magic happen, we need to register the custom protocol handler in the Windows registry. This can be done manually or automatically. First, let's do it manually. To do this, open the Windows registry as a system administrator (type "Regedit" in the start menu or run it as a command). Then, follow these steps:

 

  1. Under HKEY_CLASSES_ROOT, create a new key with the same name as the protocol (in this case, " ItemAnalyzer ").
  2. Inside the new key, add a default new string value with no name (just "Default") and set its content to "URL:protocol_name Protocol" (in this case, "URL: ItemAnalyzer Protocol").

3. Add a new string with the name "URL Protocol" and no content.

4. Under the " ItemAnalyzer" key, add the following keys hierarchically: shell\open\command

5. Inside the "command" key, add a new string with an empty name (just "Default") and set its value to the location of the executable followed by %1, which represents the argument to pass to the executable.

After completing these steps, if you open the run window and type "ItemAnalyzer:// " and press enter, the application will be launched. You can also do this from the browser, and the browser will prompt you for confirmation before launching the application.

Now, let's proceed to the implementation of an action within Acumatica that will initiate the opening of a desktop application when activated. Specifically, we want to create an action on the Sales Order screen that, will execute a specified program to run our desktop application and pass the InventoryCD as an argument.

namespace AcuStockItemAnalizer
{
    public class SOOrderEntryExt : PXGraphExtension<SOOrderEntry>
    {
        public static bool IsActive() => true;
 
        #region Action
        public PXAction<SOOrder> RunStockItemAnalyzer;
        
        [PXUIField(DisplayName = "Run Item Analyzer")]
        [PXButton(CommitChanges = true)]
        protected virtual IEnumerable runStockItemAnalyzer(PXAdapter adapter)
        {
            var tranRow = Base.Transactions.Current;
            if (tranRow != null)
            {
                var inventoryItem = PXSelectorAttribute.Select<SOLine.inventoryID>(Base.Caches[typeof(SOLine)], tranRow, tranRow?.InventoryID) as InventoryItem;
                if (inventoryItem != null)
                {
                    string urlProtocol = string.Format($"ItemAnalyzer://{inventoryItem.InventoryCD}");
                    throw new PXRedirectToUrlException(urlProtocol, null);
                }
            }
            
            return adapter.Get();
        }
        #endregion
    }
}

As demonstrated in the example, activating the action initiates the opening of a desktop application, with the InventoryCD being passed as a parameter.

 

To automate the process of registering a custom protocol handler, you can change the registry during the application installation or have the application do it automatically. One way to do this in C# is to use the code provided.

Another option is to create a .REG file. This is a plain text file with a .REG extension that contains registry entries, and it can be used to add or modify registry entries automatically when opened. When you double-click a .REG file, it will be imported into the registry, and the registry entries it contains will be added or modified. This can be a convenient way to automatically register custom protocol handlers without manually editing the registry.

 

Windows Registry Editor Version 5.00

 

[HKEY_CLASSES_ROOT\ItemAnalyzer]

@="URL: ItemAnalyzer Protocol"

"URL Protocol"=""

 

[HKEY_CLASSES_ROOT\ItemAnalyzer\shell]

 

[HKEY_CLASSES_ROOT\ItemAnalyzer\shell\open]

 

[HKEY_CLASSES_ROOT\ItemAnalyzer\shell\open\command]

@="\"C:\\TestApplication\\StockItemAnalizer.exe\" \"%1\""

 

Acumatica: SMS Provider, Twilio SMS provider, send SMS in action

Hello everybody,

Today I want to share one approach, how to send SMS message from custom action in Acumatica.

Acumatica has several sms providers in SalesDemo data base, it depends from Acumatica’s version, so, we will use Twilio provider. On SMS Provider screen you can find authorization parameters from each provider, as on screen shot from (22r1 build):

First you need to add two references from Acumatica’s Bin folder to your project in VS:

PX.SmsProvider.Core.dll

PX.SmsProvider.UI.dll

 

Then create graph extension for any screen that you need and develop next logic in custom button “Send SMS”.

Also, you need to use Dependency Injection (ASP.net) and IReadOnlyDictionary interface and define field in graph extension with ISmsProvider type.

The main logic consists from next steps: prepare list of settings (List<ISmsProviderSetting>), create SmsProvider fabric (using dependency injection), load setting to fabric, prepare SMS message and send it in async mode. Also, you can add PXLongOperation feature in action, it doesn’t have conflicts with async method.

Source code example here:

public class SOOrderEntryExt : PXGraphExtension<SOOrderEntry>
{
    public static bool IsActive() => true;
 
 
    [InjectDependency]
    internal IReadOnlyDictionary<string, ISmsProviderFactory> ProviderFactories { getset; }
    private ISmsProvider _currentProvider;
 
 
    public PXAction<SOOrder> SendSMS;
    [PXButton()]
    [PXUIField(DisplayName = "Send SMS", MapEnableRights = PXCacheRights.Select, MapViewRights = PXCacheRights.Select)]
    protected virtual void sendSMS()
    {
        SendSMSNotification(this.Base, "+380990123456""Test SMS message from Acumatica server");
    }
 
    public virtual void SendSMSNotification(PXGraph graphstring phonestring smsMessage)
    {
        string parsePhoneTo = phone.Trim(' ''('')''-');
 
        var selectProviderAuth = SelectFrom<SmsPluginParameter>.InnerJoin<SmsPlugin>.On<SmsPluginParameter.pluginName.IsEqual<SmsPlugin.name>>.
            Where<SmsPlugin.isDefault.IsEqual<@P.AsBool>>.View.Select(graph, true);
 
        string ACCOUNT_SID = string.Empty;
        string SECRET = string.Empty;
        string FROM_PHONE_NBR = string.Empty;
 
        var setting = new List<TGSmsProviderSettings>();
 
        foreach (SmsPluginParameter item in selectProviderAuth)
        {
            if (item.PluginTypeName != "PX.SmsProvider.Twilio.TwilioVoiceProvider")
                throw new PXException("No preferences for Twilio provider!");
 
            switch (item.Name)
            {
                case nameof(ACCOUNT_SID):
                    {
                        ACCOUNT_SID = item.Value;
                        setting.Add(new TGSmsProviderSettings()
                        {
                            Name = nameof(ACCOUNT_SID),
                            Value = ACCOUNT_SID,
                        });
                        break;
                    }
                case nameof(SECRET):
                    {
                        SECRET = item.Value;
                        setting.Add(new TGSmsProviderSettings()
                        {
                            Name = nameof(SECRET),
                            Value = SECRET,
                        });
                        break;
                    }
                case nameof(FROM_PHONE_NBR):
                    {
                        FROM_PHONE_NBR = item.Value;
                        setting.Add(new TGSmsProviderSettings()
                        {
                            Name = nameof(FROM_PHONE_NBR),
                            Value = FROM_PHONE_NBR,
                        });
                        break;
                    }
            }
        }
 
        if (string.IsNullOrEmpty(ACCOUNT_SID) || string.IsNullOrEmpty(FROM_PHONE_NBR) || string.IsNullOrEmpty(SECRET))
            throw new PXException("No preferences for Twilio provider!");
 
        SendSmSMessage(setting, parsePhoneTo, smsMessage);
    }
 
    private void SendSmSMessage(List<TGSmsProviderSettings> settingsstring phonestring body)
    {
        if (this._currentProvider != nullreturn;
 
        this._currentProvider = this.ProviderFactories["PX.SmsProvider.Twilio.TwilioVoiceProvider"].Create();
        this._currentProvider.LoadSettings(settings);
 
        var messageRequest = new SendMessageRequest()
        {
            RecepientPhoneNbr = phone,
            RecepientSMSMessage = body
        };
 
        try
        {
            _currentProvider.SendMessageAsync(messageRequest, CancellationToken.None).Wait();
        }
        catch (AggregateException ex)
        {
            string str = string.Join(";", ex.InnerExceptions.Select(x => x.Message));
            throw new PXException(str);
        }
    }
}
 
 
public class TGSmsProviderSettings : ISmsProviderSetting
{
    public string Name { getset; }
    public string Description { getset; }
    public string Value { getset; }
}

Summary

With provided code and Twilio you can send sms messages to your USA based customers. Similar activites may be done for other customers, but out of the box Acumatica allows to use Twilio.

PXAggregateAttribute usage for saving of your development time

Hi everybody,

today I want to share one of the insights from code and code, which was conducted by Stéphane Bélanger, and which seems useful, also may be controversial. But still, you may like it. So let me introduce or re-introduce PXAggregateAttribute .

If to sum up, purpose of PXAggregateAttribute, is merging of couple of attributes into single one. Consider following situation. You need to have selector Active customer over multiple places in Acumatica: at Purchase orders form, and Sales order form and at Shipment form. And difference between them will be zero, or close to that. Wouldn't that be nice, to declare this attribute in one place, and then to re-use it everywhere else? Of course yes. And for that purpose, Acumatica introduced attribute PXAggregateAttribute. 

Below goes code sample, of how that can be used, and re-used:

[PXInt()]
[PXUIField(DisplayName = "Active Customer")]
[PXDefault()]
[PXSelector(typeof(Search<BAccountR.bAccountID,
    Where<BAccountR.status, Equal<BAccount.status.active>>>))]
public class ActiveCustomer : PXAggregateAttribute {}
 
 
public class SOShipmentExt : PXCacheExtension<SOShipment>
{
    public abstract class activeCustomer : PX.Data.BQL.BqlInt.Field<activeCustomer> { }
 
    // Acuminator disable once PX1030 PXDefaultIncorrectUse [For demonstration purposes that will be sufficient]
    [ActiveCustomer]
    public Int32? ActiveCustomer { getset; }
}
 
public class POOrderExt : PXCacheExtension<POOrder>
{
    public abstract class activeCustomer : PX.Data.BQL.BqlInt.Field<activeCustomer> { }
 
    // Acuminator disable once PX1030 PXDefaultIncorrectUse [For demonstration purposes that will be sufficient]
    [ActiveCustomer]
    public Int32? ActiveCustomer { getset; }
}
 
public class SOOrderExt : PXCacheExtension<SOOrder>
{
    public abstract class activeCustomer : PX.Data.BQL.BqlInt.Field<activeCustomer> { }
 
    // Acuminator disable once PX1030 PXDefaultIncorrectUse [For demonstration purposes that will be sufficient]
    [ActiveCustomer]
    public Int32? ActiveCustomer { getset; }
}

 As you can see, above our class ActiveCustomer, we've declared bundle of attributes, and then everywhere else, we've used them, but instead of duplication of code, we've re-used them as single line.

 

Change field state dynamically in Acumatica. Or changing field type in Acumatica

Hello friends.

Today I will tell you how we can dynamically change the state of the field in a grid. I want to notice that this way works only for grid and will not work with Form.

In our case we will create DAC Extension for SOLine with 2 fields.

First field will choose the type we want to convert the field into and in the second field will interact with it.

In this example I made fields PXDBString on purpose to show how they are saved to the database.

[PXCacheName(SoLineExtCacheName)]
public class SoLineExt : PXCacheExtension<SOLine>
{
    private const string SoLineExtCacheName = "SoLineExt";
    public static bool IsActive() => true;
 
    #region UsrSlsOrdPrimaryReasonCode
 
    [PXDBString(255)]
    [PXStringList(
        new[] { "1""2""3""4""5" },
        new[] { "DropDown""TextBox""DateTime""CheckBox""Selector" })]
    [PXUIField(DisplayName = "FieldOne")]
    public string UsrFieldOne { getset; }
 
    public abstract class usrFieldOne : BqlString.Field<usrFieldOne>
    {
    }
 
    #endregion
 
    #region UsrSlsOrdSecondaryReasonCode
 
    [PXDBString(255)]
    [PXUIField(DisplayName = "FieldTwo")]
    public string UsrFieldTwo { getset; }
 
    public abstract class usrFieldTwo : BqlString.Field<usrFieldTwo>
    {
    }
 
    #endregion
 
}

 

The next step should be creating the GraphExtension for the graph.

Create a FieldSelecting event for UsrFieldTwo that will dynamically change the state.

We will also check if UsrFieldOne is empty then by default we can create our UsrFieldTwo as a text field.

[PXCacheName(SoOrderEntryExtCacheName)]
public class SOrderEntryExt : PXGraphExtension<SOOrderEntry>
{
    private const string SoOrderEntryExtCacheName = "SoOrderEntryExt";
    public static bool IsActive() => true;
 
    public PXSelect<FixedAsset> FixedAssets; // Here we've a view that we'll show in a selector
 
    protected void _(Events.FieldSelecting<SOLine, SoLineExt.usrFieldTwo> args)
    {
        var fieldOne = args.Row.GetExtension<SoLineExt>()?.UsrFieldOne;
        if (args.Row == null || string.IsNullOrWhiteSpace(fieldOne))
        {
            return;
        }

 

The next step is to define a Switch conditional construct in which we will check the type we should transform UsrFieldTwo into and return to text field.

        switch (fieldOne)
        {
            case "1":
                args.ReturnState = PXStringState.CreateInstance(args.ReturnState, 100, truetypeof(SoLineExt.usrFieldTwo).Name,
                    false, -1, string.Empty, new[] { "val_1""val_2""val_3", }, new[] { "val_1""val_2""val_3", }, falsenull);
                // We can uncomment this line if need to MultiSelect in dropdown.
                //((PXStringState)args.ReturnState).MultiSelect = true;
                break;
            case "2":
                args.ReturnState = PXStringState.CreateInstance(args.ReturnState, 100, null,
                    typeof(SoLineExt.usrFieldTwo).Name, false, -1, nullnullnulltruenull);
                break;
            case "3":
                args.ReturnState = PXDateState.CreateInstance(args.ReturnState, typeof(SoLineExt.usrFieldTwo).Name, false, -1,
                    nullnullnullnull);
                break;
            case "4":
                args.ReturnState = PXFieldState.CreateInstance(args.ReturnState, typeof(bool), falsefalse, -1,
                    nullnullfalsetypeof(SoLineExt.usrFieldTwo).Name, nullnullnull, PXErrorLevel.Undefined, truetrue,
                    null, PXUIVisibility.Visible, nullnullnull); break;
            case "5":
                var state = PXFieldState.CreateInstance(args.ReturnState,
                    typeof(string), falsetrue, 1, nullnullnulltypeof(SoLineExt.usrFieldTwo).Name);
                state.ViewName = nameof(FixedAssets);
                state.DescriptionName = nameof(FixedAsset.description);
                state.FieldList = new[]
                {
                    nameof(FixedAsset.assetID),
                    nameof(FixedAsset.description),
                    nameof(FixedAsset.assetTypeID),
                    nameof(FixedAsset.assetCD)
                };
                var selectorCache = Base.Caches<FixedAsset>();
                state.HeaderList = new[]
                {
                    PXUIFieldAttribute.GetDisplayName<FixedAsset.assetID>(selectorCache),
                    PXUIFieldAttribute.GetDisplayName<FixedAsset.description>(selectorCache),
                    PXUIFieldAttribute.GetDisplayName<FixedAsset.assetTypeID>(selectorCache),
                    PXUIFieldAttribute.GetDisplayName<FixedAsset.assetCD>(selectorCache),
                };
                state.DisplayName = PXUIFieldAttribute.GetDisplayName<SoLineExt.usrFieldTwo>(args.Cache);
                state.Visible = true;
                state.Visibility = PXUIVisibility.Visible;
                state.Enabled = true;
                args.ReturnState = state;
                break;
            default:
                args.ReturnState = PXStringState.CreateInstance(args.ReturnState, 100, null,
                    typeof(SoLineExt.usrFieldTwo).Name, false, -1, nullnullnulltruenull);
                break;
        }
 
    }
}

 After we have prepared our GraphExtension and CacheExtension we need to add our fields to the View, so we can do this through the Customization Editor for clarity.

Very important point! Since we dynamically change the type of our field UsrFieldTwo, you must set MatrixMode="true" for this column:

That's it, now we can make a publish and check it out.

You must remember that all fields that are specified in the list in the database will be stored as a string, so do not forget to convert them to the correct type when you work with them, to avoid problems with the type of ghosting.

If the field is empty then by default it will be a text field.

  • If you select dropdown then we get the value we set in e.ReturnState.

  • The text field is identical to the empty field.

  • If you select CheckBox, our field will have two states True or False.

  • If we select DateTime we can select a date from the DateTimePicker.

 

  • Of course, Selector. This will display the data from our previously defined FixedAsset view.

Let's also see how this data is stored in the database which is demonstrated by sampling.

That's all for now, thank you for your attention, I hope this article will be useful for you

All for successful coding.

 

How to add GI to side panel and Pivot table to side panel

Hello everybody,

Today a want to share with you approach how to add GI to Side Panel, add Pivot Table to Side Panel, and how current row (current field value) of screen bounds with filter of GI and PT.

Also, I will show how to add all custom features with GI and PT to customization package.

As example, we will add side panel to Customers screen and add two actions, first - custom GI report about sales, second – pivot table with information about Sales Order that connected to current customer on screen.

  1. First, we create custom GI report with joins of tables, result grid with columns that we need for pivot table.

Pivot tables in Acumatica are created and based on GI. All columns in ResultGrid tab will able in pivot table.

 

Add Parameter and Conditions for it.

Click button “VIEW INQUIRY” and check how works result and filter:

Create and setup pivot table as we need:

Click “Save as Pivot”, enter name of pivot table, select check box “Shared Configuration”

Then Acumatica show additional tab with Pivot Table as on screen-shot

Setup Rows, Columns and Values for pivot table, then unclick “Edit pivot table” button  

Pivot table will look as on screen-shot. Also you can drag and drop field between Rows, Columns and Values on pivot table result as you need:

Add side panel to Customer screen (AR303000).

First create new customization package and add AR303000 screen to it.

Save new action in customization and publish customization. Check work side panel with GI on Customers screen:

Add Pivot table to side panel.

Acumatica hides tab of GI with pivot table on side panel and we can see only GI report grid on side panel.

But it is opportunity in Acumatica to add pivot table to side panel using dashboard.

Also we will setup dashboard filter and pipeline it with current customer and pivot table.

  • Create custom dashboard and add parameters as on screen-shot:

Click “VIEW” and setup layout of dashboard

Add pivot table to dashboard: select our custom GI report and Pivot Table (required fields):

Click “FILTER SETTINGS”, add a new and setup it:

Click “FINISH” and exit from DESING mode of dashboard.

Add dashboard with pivot table to side panel.

Open customization package, add new action with side panel type to Customer screen. Select our dashboard ass Destination Screen, also setup Navigation Parameters:

Click OK and Publish customization.

Check how works side panel with Pivot Table. Click “Next” on screen and check how pivot table changes data, depends from current customer:

 

How to get started with Acumatica development

Hi everybody,

below goes video, which describes on how to get started with Acumatica development:

In that video you'll find out:

1. How to install specific Acumatica build

2. How to debug C# code written by you in Visual Studio and Customization designer

3. How to get possibility to debug Acumatica source code

4. Default user name and password of Acumatica instnace

And much much more. Please watch and support with your likes!

 

 

Acumatica added RabbitMQ and going to replace MSMQ

Hi everybody,

Today I want to write a few words regarding Acumatica making a decision on adding RabbitMQ.

If you are going to install Acumatica 2022 R2, on one of the steps of installation, you may see this:

As you can figure out from the caption, by default Acumatica now installs RabbitMQ.

 

 

 

Another process has updated the {Table} record. Your changes will be lost

Hello everybody,

Today a want to share with you couple approaches that can help you to fix a famous Acumatica’s error:

“Another process has updated the {Table} record. Your changes will be lost”

You can get this error when you open two the same screens with the same record from DB and then modify data on both screens and click Save.

Or maybe you have custom logic that run some functionality in PXLongOperation (run in multi-threading mode) and one record from DB can be modified by different threads and then during persisting you will get this error.

Or maybe you need to create and to release several documents during code logic that use the same record in DB (for example Create/Release Invoice and then Create/Release Payment that updates ARRegister table).

We get this error when try persist in DB record that was modified before by another graph or process and record has another version (another value) of TimeStamp field.

So, TimeStamp control version in Acumatica and DB is done using field TimeStamp (or Tstamp) with [PXDBTimestamp] attribute in the DAC table. When record is updated, the TimeStamp field increase own value at 1. Every time when a graph persist record to DB, it verifies version of the record to be sure that the record is not changed by another process.

We have three approaches that can help us fix this error and run code logic till the end. (Two first approaches you can find in source code of Acumatica site, Acumatica uses it often):

  1. Use SelectTimeStamp() method of the graph:

When you invoke this methos, graph selects and sets TimeStamp field with new version and then you can persist data to DB.

Here one of examples from Acumatica’s VendorMaint graph, Persist method:

public override void Persist()
{
    using (PXTransactionScope ts = new PXTransactionScope())
    {
        bool persisted = false;
        try
        {
            BAccountRestrictionHelper.Persist();
            persisted = (base.Persist(typeof(Vendor), PXDBOperation.Update) > 0);
        }
        catch
        {
            Caches[typeof(Vendor)].Persisted(true);
            throw;
        }
        base.Persist();
        if (persisted)
        {
            base.SelectTimeStamp();
        }
        ts.Complete();
    }
}

 

Another example:

private void PrepareForPOCreate(List<SOLine> listSO)
{
    foreach (SOLine item in listSO)
    {
        item.Qty = item.GetExtension<APSOLineExt>().UsrMasterSOQty;
 
        var inventoryItem = UpdatePOOrderExtension.CheckDefVendor(this.Base, item.InventoryID);
 
        if (inventoryItem == null)
        {
            Base.Caches<SOLine>().SetValueExt<SOLine.pOCreate>(item, false);
            Base.Transactions.Cache.Update(item);
        }
    }
 
    Base.SelectTimeStamp();
    Base.Save.Press();
}

 2. Use PXTimeStampScope.SetRecordComesFirst() method:

Sometimes first approach doesn’t help and error still is raised.

 By default, Acumatica checks TimeStamp version of graph only when key fields are modified. But SetRecordComesFirst() method activates RecordComesFirst flag and Acumatica check TimeStamp version for all changes in cache.

Here is example how to create and release Payment:

private static ARPayment CreateAndReleasePayment(ARInvoice arInvoice)
 {
     ARPaymentEntry paymentEntry = PXGraph.CreateInstance<ARPaymentEntry>();
 
     var arAdjust = SelectFrom<ARAdjust>.Where<ARAdjust.adjdRefNbr.IsEqual<@P.AsString>>.View.Select(paymentEntry, arInvoice.RefNbr)?.TopFirst;
 
     if (arAdjust?.AdjgRefNbr == null)
     {
         paymentEntry.CreatePayment(arInvoice, null, arInvoice.DocDate, arInvoice.FinPeriodID, false);
 
         paymentEntry.Document.Current.ExtRefNbr = arInvoice.DocDesc;
         paymentEntry.Document.Current.BranchID = arInvoice.BranchID;
         paymentEntry.Document.UpdateCurrent();
         paymentEntry.Save.Press();
     }
     else
     {
         paymentEntry.Document.Current = SelectFrom<ARPayment>.Where<ARPayment.refNbr.IsEqual<@P.AsString>>.View.Select(paymentEntry, arAdjust.AdjgRefNbr)?.TopFirst;
     }
 
     ARPayment arPayment = paymentEntry.Document.Current;
 
     paymentEntry.Clear();
 
     ARRegister doc = arPayment;
     List<ARRegisterlist = new List<ARRegister>() { doc };
 
     using (new PXTimeStampScope(null))
     {
         PXTimeStampScope.SetRecordComesFirst(typeof(ARRegister), true);
 
         try
         {
             ARDocumentRelease.ReleaseDoc(list, false);
         }
         catch (PXException e)
         {
             PXTrace.WriteError(e.Message);
         }
     }
 
     return arPayment;
 }

Acumatica’s usage of this method in ARInovoiceEntry:

public void ReleaseProcess(List<ARRegister> list)
        {
            PXTimeStampScope.SetRecordComesFirst(typeof(ARInvoice), true);
 
            ARDocumentRelease.ReleaseDoc(list, falsenull, (ab) => { });
        }

 3. Use PXTimeStampScope.DuplicatePersisted() method:

 

The most difficult approach, but helps and fixes the error, if first and second approaches don’t work. There are no examples in Acumatica’s site source code, but below I use it two times (override persist methods):

Lazy is not necessary to use, it is just for performance, because I had long and heavy logic of process on my custom processing screen.

public class ARPaymentEntryExt : PXGraphExtension<ARPaymentEntry>
{
    public static bool IsActive() => true;
 
    [PXOverride]
    public virtual void Persist(Action baseMethod)
    {
        var updInvoices = Base.ARInvoice_DocType_RefNbr.Cache.Updated.Cast<ARInvoice>().ToList();
        var updPayments = Base.Document.Cache.Updated.Cast<ARPayment>().ToList();
 
        baseMethod?.Invoke();
 
        var lazyTempGraph = new Lazy<PXGraph>(() => PXGraph.CreateInstance<PXGraph>());
        foreach (ARInvoice updInvoice in updInvoices)
        {
            PXTimeStampScope.DuplicatePersisted(lazyTempGraph.Value.Caches[typeof(ARRegister)], updInvoice, typeof(ARInvoice));
            PXTimeStampScope.DuplicatePersisted(lazyTempGraph.Value.Caches[typeof(ARPayment)], updInvoice, typeof(ARInvoice));
        }
        foreach (ARPayment updPayment in updPayments)
        {
            PXTimeStampScope.DuplicatePersisted(lazyTempGraph.Value.Caches[typeof(ARRegister)], updPayment, typeof(ARPayment));
        }
    }
}
public class ARDocumentReleaseExt : PXGraphExtension<ARReleaseProcess>
{
    public static bool IsActive() => true;
 
    [PXOverride]
    public virtual void Persist(Action baseMethod)
    {
        var updRegisters = Base.ARDocument.Cache.Updated.Cast<ARRegister>().ToList();
        baseMethod?.Invoke();
 
        var lazyTempGraph = new Lazy<PXGraph>(() => PXGraph.CreateInstance<PXGraph>());
 
        foreach (ARRegister updRegister in updRegisters)
        {
            PXTimeStampScope.DuplicatePersisted(lazyTempGraph.Value.Caches[typeof(ARPayment)], updRegister, typeof(ARRegister));
            PXTimeStampScope.DuplicatePersisted(lazyTempGraph.Value.Caches[typeof(ARInvoice)], updRegister, typeof(ARRegister));
        }
    }
}

 Summary

As you can see, other process has updated is kind of commonly seen error in Acumatica, and you now seen at least three ways of how to handle that

Acumatica requirements for development

Hi everybody,

today I want to leave a short note regarding of what is needed, in order to be able to develop for Acumatica ERP.

REQUIREMENTS FOR DEV MACHINE

Display resolution: Minimum 1024 × 768, Typical 1920×1080

Adobe Reader: (to open Acumatica ERP PDF documents) 2019 or later

Microsoft Office: (to view documents exported from Acumatica ERP)

  • MS Office 2019
  • MS Office 2016
  • MS Office 2013
  • MS Office 2010
  • MS Office 2007
  • MS Office 2003 with the Microsoft Office 2007 compatibility pack

IIS

Web Browsers:

  • Microsoft Edge 44 or later
  • Mozilla Firefox 82 or later
  • Apple Safari 12 or later
  • Google Chrome 87 or later

As of June 15, 2022, Microsoft Internet Explorer is no longer supported by any version of Acumatica ERP as the browser has been retired by Microsoft who now recommends Microsoft Edge.

DATABASE REQUIREMENTS

Microsoft SQL Server: 2019, 2017, or 2016

MySQL Community Edition Server: 5.7 and 8.0 64-bit edition

MariaDB: Version 10

Memory: 8 GB RAM

CPU: 2 cores; 2 GHz

Hard Disk Space: For each database, 1 GB available hard disk space. Depending on the number of transactions, additional hard disk space may be required to store large numbers of transactions.

CODE AUTHORING ENVIRONMENTS

To create stand-alone applications with Acumatica ERP or develop customizations and add-on solutions on top of Acumatica ERP, you need one of the integrated development environments (IDEs) listed below.

Operating System

  • Windows 10
  • Windows Server 2019
  • Windows Server 2022

Microsoft Visual Studio with Microsoft Web Developer Tools:

  • 20xx: Community, Professional, and Enterprise editions ( xx stands for version numbers, 09, ..., 19, 22 )
  • (OR) Rider 

Summary

If to sum upp, if you want to develop Acumatica, you'll need Windows, IIS, Database and Visual Studio or Rider

How to remove validation of the Lot/Serial Class field on the Stock Items page

Today I want to share with you the article "How to remove the validation of the Lot/Serial Class field on the Stock Items page".

Recently I had a case where I wanted to change Lot/Serial Class at any time regardless of its use, but out of the box, Acumatica doesn't give this possibility and show an error or warning "Lot/serial class cannot be changed when its tracking method as it is not compatible with the previous class and the item is in use" as it is demonstrated in the image below.

There is a possibility of this warning

The red error comes from validation on FieldVerifying, but the yellow comes from the rule in INItemPlan.inventoryID.InventoryLotSerClassIDRule. Although looks like a warning, it reverts your change so it doesn't let you to change it.

The solution of the Lot/serial class can be changed as it is not a complicated process but can be quite time-consuming.

First of all we need to create a GraphExtension where by overriding the Initialize we provide ability to change the Lot/Serial class.

And we also need to override the FieldVerifiyng event and not call the base method so that this field is not validated.

The full code is here:

[PXCacheName(InventoryItemMaintExtCacheName)]
public class InventoryItemMaintExt : PXGraphExtension<InventoryItemMaint>
{
	private const string InventoryItemMaintExtCacheName = "InventoryItemMaintExt";
	public static bool IsActive() => true;
 
	public override void Initialize()
	{
		base.Initialize();
		Base.MakeRuleWeakeningScopeFor<InventoryItem.lotSerClassID>(RuleWeakenLevel.AllowEdit);
	}
 
	protected virtual void _(Events.FieldVerifying<InventoryItem,
	InventoryItem.lotSerClassID> e, PXFieldVerifying baseMethod)
	{
		//baseMethod?.Invoke(sender, e); 
		//skip the baseMethod so Messages.ItemLotSerClassVerifying is not thrown
	}
}

 And final word, use with caution. Because you may influence plenty of other pages in Acumatica.