RE: How to retrieve Factory Configuration?

2024-02-24T19:24:54Z

Hi,

Using Liferay 7.3

I employ a straightforward method for creating a factory of configurations, facilitating the addition of multiple entries for this configuration. Furthermore, it's possible to extend additional interfaces to enable the introduction of various types of configuration setups for different kinds of fields

@ExtendedObjectClassDefinition(category = "Sample Configuration Category", factoryInstanceLabelAttribute = "sampleReminders")
@Meta.OCD(factory = true, id = "com.sample.configuration.SampleConfiguration", name = "Sample Configuration")
public interface SampleConfiguration {

   @Meta.AD(deflt = "0", name = "Start Day", required = false)
   public int startDay();

   @Meta.AD(deflt = "14", name = "End Day", required = false)
   public int endDay();

   @Meta.AD(deflt = "1", name = "Job Interval", required = false)
   public int jobInterval();

   @Meta.AD(deflt = "1", name = "Sample Reminder", required = false)
   public String sampleReminders(); // TODO - same name to be provide on factoryInstanceLabelAttribute, for showing detail in list
}

I am using this configuration in

@Component(configurationPid = "com.sample.configuration.SampleConfiguration", immediate = true, service = SampleMessageListner.class)
public class SampleMessageListner extends BaseMessageListener {

   private static final Log _log = LogFactoryUtil.getLog(SampleMessageListner.class);

   @Override
   protected void doReceive(Message message) throws Exception {
       _log.info("===== SAMPLE REMINDER START =====");
//TODO - Write Code

       _log.info("===== SAMPLE REMINDER END =====");
   }

   @Activate
   @Modified
   protected void activate(Map<String, Object> properties) {

       SampleConfiguration = ConfigurableUtil
               .createConfigurable(SampleConfiguration.class, properties);

       List<Sample> samples = new ArrayList<>();

    //TODO - Set List<Sample> over Global and Use any of method as per requirment
       samples
               .add(new Sample(sampleConfiguration.dealerStartDay(),
                       sampleConfiguration.dealerEndDay(),
                       sampleConfiguration.dealerJobInterval(),
                       sampleConfiguration.Samples()));

       _log.info(samples);

   }

   @Deactivate
   protected void deactivate() {
       schedulerEngineHelper.unregister(this);
   }

   @Reference
   private SchedulerEngineHelper schedulerEngineHelper;

   @Reference
   private TriggerFactory triggerFactory;

   @Reference(target = ModuleServiceLifecycle.PORTAL_INITIALIZED)
   private ModuleServiceLifecycle moduleServiceLifecycle;

   private volatile SampleConfiguration sampleConfiguration;

}

You can create POJO to set values

public class Sample {

private String pid;

   private int startDay;

   public int endDay;

   public int jobInterval;

   public String reminder;

   public Sample(String pid, int startDay, int endDay, int jobInterval,
           String dealerAgreementReminder) {
this.pid=pid; this.startDay = startDay;
       this.endDay = endDay;
       this.jobInterval = jobInterval;
       this.reminder = reminder;
   }

   //TODO - Create Getter / Setter and ToString and eqauls / hashcode as per your requirment

}

Add ConfigurationBeanDeclaration

@Component(service = ConfigurationBeanDeclaration.class)
public class SampleConfigurationBeanDeclaration implements ConfigurationBeanDeclaration {

   @Override
   public Class<?> getConfigurationBeanClass() {
       return SampleConfiguration.class;
   }
}

Create ManagedServiceFactory implementation logic for storing and processing configuration.

@Component(property = "service.pid=com.sample.configuration.SampleConfiguration", service = ManagedServiceFactory.class)
public class SampleConfigurationManagedServiceFactory implements ManagedServiceFactory {

   private static final Log _log = LogFactoryUtil
           .getLog(SampleConfigurationManagedServiceFactory.class);

   @Override
   public String getName() {
       return StringPool.BLANK;
   }

   @Override
   public void updated(String pid, Dictionary<String, ?> properties) throws ConfigurationException {
       _log.info("updated :" + pid);
       Dictionary<String, ?> oldProperties = SampleUtil.updateConfigurationPidsProperties(pid,
               properties);
       _rebuild();
       if (oldProperties != null) {
           _rebuild();
       }
   }

   @Override
   public void deleted(String pid) {
       _log.info("deleted : " + pid);
       SampleUtil.removeConfigurationPidsProperties(pid);
       _rebuild();

   }

   private void _rebuild() {
       _mergeSampleConfiguration();
   }

   private void _mergeSampleConfiguration() {
       SampleUtil.getConfigurationPidsProperties().forEach((pid, properties) -> {
           SampleConfiguration sampleConfiguration = ConfigurableUtil
                   .createConfigurable(SampleConfiguration.class, properties);

           _log.info(sampleConfiguration.toString());

           _populateSamples(pid, sampleConfiguration);
       });
   }

   private void _populateSamples(String pid,
           SampleConfiguration sampleConfiguration) {

       Sample Sample = createSample(pid,
               sampleConfiguration);
       SampleUtil.addSample(Sample);
   }

   private Sample createSample(String pid,
           SampleConfiguration sampleConfiguration) {
       return new Sample(pid, sampleConfiguration.startDay(),
               sampleConfiguration.endDay(),
               sampleConfiguration.jobInterval(),
               sampleConfiguration.sampleReminders());
   }

}

Create Util class for managing properties using pid and with processing of Sample class list.

public class SampleUtil {

   private static final Map<String, Dictionary<String, ?>> _configurationPidsProperties = Collections
           .synchronizedMap(new LinkedHashMap<>());

   public static Map<String, Dictionary<String, ?>> getConfigurationPidsProperties() {

       return _configurationPidsProperties;
   }

   public static Collection<Dictionary<String, ?>> getValuesConfigurationPidsProperties() {

       return _configurationPidsProperties.values();
   }

   public static Dictionary<String, ?> removeConfigurationPidsProperties(String pid) {

       return _configurationPidsProperties.remove(pid);
   }

   public static Dictionary<String, ?> updateConfigurationPidsProperties(String pid,
           Dictionary<String, ?> properties) {

       return _configurationPidsProperties.put(pid, properties);
   }

   private static final Map<String, Sample> _samples = Collections
           .synchronizedMap(new LinkedHashMap<>());

   public static void addSample(Sample value) {

       _samples.put(value.getPid(), value);

   }

   public static void updateSamples(List<Sample> values) {
       values.stream().forEach(value -> addSample(value));
   }

   public static void removeSamples() {
       _samples.clear();
   }

   public static void removeSamples(Sample value) {
       _samples.remove(value.getPid());
   }

   public static Collection<Sample> getSamples() {
       return _samples.values();
   }

}

You can directly use SampleUtil method in any of class for fetching all configuration list using factory process.

Hope you can implement based on this code.

Support Link - https://help.liferay.com/hc/en-us/articles/360028818632-Factory-Configurations

How to retrieve Factory Configuration?

2023-05-05T15:44:47Z

I would like to retrieve the configuration of an OpenID Provider inside a 6.2 style hook (I am running DXP 7.0.101).

For simple configuration, I can use ConfigurationProviderUtil, but I cannot find any example for Factory Configuration.