Process lasso pro 9.7.0.16 + x64 + portable + repack + beta

Setting the Property

Just like many other configuration options, the context path in Spring Boot can be changed by setting a property, i.e., server.servlet.context-path.

Note that this works for Spring Boot 2.x.

For Boot 1.x, the property is server.context-path.

There are multiple ways of setting this property, let’s look at these one by one.

2.1. Using application.properties / yml

The most straightforward way of changing the context path is to set the property in the application.properties/yml file:

server.servlet.context-path=/baeldung

Instead of putting the properties file in src/main/resources, we can also keep it in the current working directory (outside of the classpath).

2.2. Java System Property

We can also set the context path as a Java system property before even the context is initialized:

public static void main(String[] args) {
    System.setProperty("server.servlet.context-path", "/baeldung");
    SpringApplication.run(Application.class, args);
}

2.3. OS Environment Variable

Spring Boot can also rely on OS environment variables. On Unix based systems we can write:

$ export SERVER_SERVLET_CONTEXT_PATH=/baeldung

On Windows, the command to set an environment variable is:

> set SERVER_SERVLET_CONTEXT_PATH=/baeldung

The above environment variable is for Spring Boot 2.x.x,  If we have 1.x.x, the variable is SERVER_CONTEXT_PATH.

2.4. Command Line Arguments

We can set the properties dynamically via command line arguments as well:

$ java -jar app.jar --server.servlet.context-path=/baeldung

3.9.3 Примеры.

theme-context.js

Код

themed-button.js

Код

app.js

Код

3.9.3.2 Обновление контекста из вложенного компонента

Часто необходимо обновить контекст из компонента, который глубоко вложен
в дерево компонентов. В этом случае вы можете передать функцию через контекст,
чтобы позволить потребителям обновлять контекст:

theme-context.js

Код

theme-toggler-button.js

Код

app.js

Код

3.9.3.3 Потребление множества контекстов

Чтобы поддерживать перерисовку контекста быстрой, React должен
сделать каждого потребителя контекста отдельным узлом в дереве.

Код

Если два и более значения контекста часто используются вместе, вы можете
рассмотреть возможность создания вашего собственного компонента,
который будет их предоставлять.

3.9.3.4 Доступ к контексту в методах жизненного цикла

Доступ к значениям из контекста в методах жизненного цикла является довольно
частой ситуацией. Вместо добавления контекста в каждый метод жизненного цикла
вам просто нужно передать его как свойство, а затем работать с ним так же,
как и с обычным свойством.

Код

3.9.3.5 Потребление контекста старшим компонентом (HOC-ом)

Некоторые типы контекстов могут потребляться многими компонентами (например, тема или локализация).
Может быть утомительно явно обертывать каждую зависимость с помощью
элемента . Старший компонент может помочь избежать этого.

Например, компонент кнопки может потреблять контекст темы следующим образом:

Код

Для нескольких компонентов это выглядит хорошо, но что, если бы мы
захотели использовать контекст темы во множестве мест?

Мы могли бы создать старший компонент с :

Код

Теперь любой компонент, который зависит от контекста темы, может легко
подписаться на него с помощью созданной нами функции :

Код

3.9.3.6 Передача ссылок ref в потребители контекста

Одна из проблем с API-интерфейсом заключается в том,
что ссылки не передается автоматически обернутым элементам. Чтобы
обойти это, используйте :

fancy-button.js

Код

app.js

Код

@ComponentScan With Arguments

Now let’s customize the paths for scanning. For example, let’s say we want to exclude the Rose bean.

3.1. @ComponentScan for Specific Packages

We can do it in a few ways. First, we can change the base package:

@ComponentScan(basePackages = "com.baeldung.componentscan.springapp.animals")
@Configuration
public class SpringComponentScanApp {
   // ...
}

Now the output will be:

springComponentScanApp
cat
dog
exampleBean

Let’s see what’s behind this:

  • springComponentScanApp is created as it’s a configuration passed as an argument to the AnnotationConfigApplicationContext
  • exampleBean is a bean configured inside the configuration
  • cat and dog are in the specified com.baeldung.componentscan.springapp.animals package

All of the above-listed customizations are applicable in Spring Boot too. We can use @ComponentScan together with @SpringBootApplication and the result will be the same:

@SpringBootApplication
@ComponentScan(basePackages = "com.baeldung.componentscan.springbootapp.animals")

3.2. @ComponentScan with Exclusions

Another way is to use a filter, specifying the pattern for the classes to exclude:

@ComponentScan(excludeFilters = 
  @ComponentScan.Filter(type=FilterType.REGEX,
    pattern="com\\.baeldung\\.componentscan\\.springapp\\.flowers\\..*"))

We can also choose a different filter type, as the annotation supports several flexible options for filtering the scanned classes:

@ComponentScan(excludeFilters = 
  @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = Rose.class))

Using SpringApplicationBuilder API

The SpringApplicationBuilder class provides a fluent API to create a parent-child relationship between contexts using parent(), child() and sibling() methods.

To exemplify the context hierarchy, we’ll set up a non-web parent application context with 2 child web contexts.

To demonstrate this, we’ll start two instances of embedded Tomcat each with its own web application context and both running in a single JVM.

3.1. Parent Context

To begin, let’s create a service bean along with a bean definition class which reside in the parent package. We want this bean to return a greeting which is displayed to the client of our web application:

@Service
public class HomeService implements IHomeService {

    public String getGreeting() {
        return "Welcome User";
    }
}

And the bean definition class:

@Configuration
@ComponentScan("com.baeldung.parent")
public class ServiceConfig {}

Next, we’ll create the configuration for the two child contexts.

3.2. Child Context

Since all contexts are configured using the default configuration file, we need to provide separate configurations for properties which cannot be shared among contexts such as server ports.

To prevent conflicting configurations being picked up by the auto-configuration, we’ll also keep the classes in separate packages.

Let’s start by defining a properties file for the first child context:

server.port=8081
server.servlet.context-path=/ctx1

spring.application.admin.enabled=false
spring.application.admin.jmx-name=org.springframework.boot:type=Ctx1Rest,name=Ctx1Application

Note that we’ve configured the port and context path, as well as a JMX name so the application names don’t conflict.

Let’s now add the main configuration class for this context:

@Configuration
@ComponentScan("com.baeldung.ctx1")
@EnableAutoConfiguration
public class Ctx1Config {
    
    @Bean
    public IHomeService homeService() {
        return new GreetingService();
    }
}

This class provides a new definition for the homeService bean that will overwrite the one from the parent.

Let’s see the definition of the GreetingService class:

@Service
public class GreetingService implements IHomeService {

    public String getGreeting() {
        return "Greetings for the day";
    }
}

Finally, we’ll add a controller for this web context that use the homeService bean to display a message to the user:

@Controller
public class Ctx1Controller {

    @Autowired
    HomeService homeService;

    @GetMapping("/home")
    @ResponseBody
    public String greeting() {

        return homeService.getGreeting();
    }
}

3.3. Sibling Context

For our second context, we’ll create a controller and configuration class which are very similar to the ones in the previous section.

This time, we won’t create a homeService bean – as we’ll access it from the parent context.

First, let’s add a properties file for this context:

server.port=8082
server.servlet.context-path=/ctx2

spring.application.admin.enabled=false
spring.application.admin.jmx-name=org.springframework.boot:type=WebAdmin,name=SpringWebApplication

And the configuration class for the sibling application:

@Configuration
@ComponentScan("com.baeldung.ctx2")
@EnableAutoConfiguration
@PropertySource("classpath:ctx2.properties")
public class Ctx2Config {}

Let’s also add a controller, which has HomeService as a dependency:

@RestController
public class Ctx2Controller {

    @Autowired
    IHomeService homeService;

    @GetMapping(value = "/greeting", produces = "application/json")
    public String getGreeting() {
        return homeService.getGreeting();
    }
}

In this case, our controller should get the homeService bean from the parent context.

3.4. Context Hierarchy

Now we can put everything together and define the context hierarchy using SpringApplicationBuilder:

public class App {
    public static void main(String[] args) {
        new SpringApplicationBuilder()
          .parent(ParentConfig.class).web(WebApplicationType.NONE)
          .child(WebConfig.class).web(WebApplicationType.SERVLET)
          .sibling(RestConfig.class).web(WebApplicationType.SERVLET)
          .run(args);
    }
}

Finally, on running the Spring Boot App we can access both applications at their respective ports using localhost:8081/ctx1/home and localhost:8082/ctx2/greeting.

Standard Context Events

In fact, there’re a variety of built-in events in Spring, that lets a developer hook into the lifecycle of an application and the context and do some custom operation.

Even though we rarely use these events manually in an application, the framework uses it intensively within itself. Let’s start by exploring various built-in events in Spring.

2.1. ContextRefreshedEvent

On either initializing or refreshing the ApplicationContext, Spring raises the ContextRefreshedEvent. Typically a refresh can get triggered multiple times as long as the context has not been closed.

Notice that, we can also have the event triggered manually by calling the refresh() method on the ConfigurableApplicationContext interface.

2.2. ContextStartedEvent

By calling the start() method on the ConfigurableApplicationContext, we trigger this event and start the ApplicationContext. As a matter of fact, the method is typically used to restart beans after an explicit stop. We can also use the method to deal components with no configuration for autostart.

Here, it’s important to note that the call to start() is always explicit as opposed to refresh().

2.3. ContextStoppedEvent

A ContextStoppedEvent is published when the ApplicationContext is stopped, by invoking the stop() method on the ConfigurableApplicationContext. As discussed earlier, we can restart a stopped event by using start() method.

2.4. ContextClosedEvent

This event is published when the ApplicationContext is closed, using the close() method in ConfigurableApplicationContext.
In reality, after closing a context, we cannot restart it.

A context reaches its end of life on closing it and hence we cannot restart it like in a ContextStoppedEvent.

@ComponentScan Without Arguments

2.1. Using @ComponentScan in a Spring Application

With Spring, we use the @ComponentScan annotation along with @Configuration annotation to specify the packages that we want to be scanned. @ComponentScan without arguments tells Spring to scan the current package and all of its sub-packages.

Let’s say we have the following @Configuration in com.baeldung.componentscan.springapp package:

@Configuration
@ComponentScan
public class SpringComponentScanApp {
    private static ApplicationContext applicationContext;

    @Bean
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }

    public static void main(String[] args) {
        applicationContext = 
          new AnnotationConfigApplicationContext(SpringComponentScanApp.class);

        for (String beanName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanName);
        }
    }
}

Also, let’s say we have the Cat and Dog components in com.baeldung.componentscan.springapp.animals package:

package com.baeldung.componentscan.springapp.animals;
// ...
@Component
public class Cat {}
package com.baeldung.componentscan.springapp.animals;
// ...
@Component
public class Dog {}

And finally, we have the Rose component in com.baeldung.componentscan.springapp.flowers package:

package com.baeldung.componentscan.springapp.flowers;
// ...
@Component
public class Rose {}

The output of the main() method will contain all the beans of com.baeldung.componentscan.springapp package and of its sub-packages:

springComponentScanApp
cat
dog
rose
exampleBean

Note that the main application class is also a bean as it’s annotated with @Configuration, which is a @Component.

Also, note that the main application class and the configuration class are not necessarily the same. If they are different, it doesn’t matter where to put the main application class. Only the location of the configuration class matters as component scanning starts from its package by default.

Finally, note that in our example @ComponentScan is equivalent to:

@ComponentScan(basePackages = "com.baeldung.componentscan.springapp")

where basePackages argument is a package or an array of packages for scanning.

2.2. Using @ComponentScan in a Spring Boot Application

The trick with Spring Boot is that many things happen implicitly. We use the @SpringBootApplication annotation, but it’s just a combination of three annotations:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Let’s create a similar structure in com.baeldung.componentscan.springbootapp package. This time the main application will be:

package com.baeldung.componentscan.springbootapp;
// ...
@SpringBootApplication
public class SpringBootComponentScanApp {
    private static ApplicationContext applicationContext;

    @Bean
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }

    public static void main(String[] args) {
        applicationContext = SpringApplication.run(SpringBootComponentScanApp.class, args);
        checkBeansPresence(
          "cat", "dog", "rose", "exampleBean", "springBootComponentScanApp");

    }

    private static void checkBeansPresence(String... beans) {
        for (String beanName : beans) {
            System.out.println("Is " + beanName + " in ApplicationContext: " + 
              applicationContext.containsBean(beanName));
        }
    }
}

All other packages and classes remain the same, we’ll just copy them to the nearby com.baeldung.componentscan.springbootapp package.

Spring Boot scans packages similarly to our previous example. Let’s check the output:

Is cat in ApplicationContext: true
Is dog in ApplicationContext: true
Is rose in ApplicationContext: true
Is exampleBean in ApplicationContext: true
Is springBootComponentScanApp in ApplicationContext: true

The reason we’re just checking the beans for existence in our second example (as opposed to printing out all the beans), is that the output would be too large.

This is because of the implicit @EnableAutoConfiguration annotation which makes Spring Boot create many beans automatically, relying on the dependencies in pom.xml file.

contextlib.closing()

Модуль contextlib содержит несколько полезных утилит. Первая – это класс closing, который закроет объект по завершению определенного блока кода. В есть пример кода, похожий на следующий:

Python

from contextlib import contextmanager

@contextmanager
def closing(db):
try:
yield db.conn()
finally:
db.close()

1
2
3
4
5
6
7
8

fromcontextlibimportcontextmanager

@contextmanager

defclosing(db)

try

yielddb.conn()

finally

db.close()

В целом, мы создаем закрывающую функцию, которая завернута в контекстный менеджер. Это эквивалент того, что делает класс closing. Но есть небольшая разница: вместо декоратора, мы можем использовать класс class в нашем операторе with. Давайте взглянем:

Python

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen(‘http://www.google.com’)) as webpage:
for line in webpage:
# обрабатываем строку…
pass

1
2
3
4
5
6
7

fromcontextlibimportclosing

fromurllib.request importurlopen

withclosing(urlopen(‘http://www.google.com’))aswebpage

forline inwebpage

# обрабатываем строку…

pass

В данном примере мы открыли страницу URL, но обернули её в наш класс closing. Это приведет к закрытию дескриптора веб-страницы, сразу после выхода из блока кода оператора with.

Теория и практика. Быстрая проверка задач и подсказки к ошибкам на русском языке.
Работает в любом современном браузере.

Writing the Test

3.1. The Business Logic

First, let’s create a simple service that we’ll be testing:

@Service
public class NameService {
    public String getUserName(String id) {
        return "Real user name";
    }
}

And inject it into the UserService class:

@Service
public class UserService {

    private NameService nameService;

    @Autowired
    public UserService(NameService nameService) {
        this.nameService = nameService;
    }

    public String getUserName(String id) {
        return nameService.getUserName(id);
    }
}

For this tutorial, the given classes return a single name regardless of the id provided. This is done so that we don’t get distracted by testing any complex logic.

We’ll also need a standard Spring Boot main class to scan the beans and initialize the application:

@SpringBootApplication
public class MocksApplication {
    public static void main(String[] args) {
        SpringApplication.run(MocksApplication.class, args);
    }
}

3.2. The Tests

Now let’s move on to the test logic. First of all, we have to configure application context for the tests:

@Profile("test")
@Configuration
public class NameServiceTestConfiguration {
    @Bean
    @Primary
    public NameService nameService() {
        return Mockito.mock(NameService.class);
    }
}

The @Profile annotation tells Spring to apply this configuration only when the “test” profile is active. The @Primary annotation is there to make sure this instance is used instead of a real one for autowiring. The method itself creates and returns a Mockito mock of our NameService class.

Now we can write the unit test:

@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = MocksApplication.class)
public class UserServiceUnitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private NameService nameService;

    @Test
    public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
        Mockito.when(nameService.getUserName("SomeId")).thenReturn("Mock user name");
        String testName = userService.getUserName("SomeId");
        Assert.assertEquals("Mock user name", testName);
    }
}

We use the @ActiveProfiles annotation to enable the “test” profile and activate the mock configuration we wrote earlier. Because of this, Spring autowires a real instance of the UserService class, but a mock of the NameService class. The test itself is a fairly typical JUnit+Mockito test. We configure the desired behavior of the mock, then call the method which we want to test and assert that it returns the value that we expect.

It’s also possible (though not recommended) to avoid using environment profiles in such tests. To do so, remove the @Profile and @ActiveProfiles annotations and add an @ContextConfiguration(classes = NameServiceTestConfiguration.class) annotation to the UserServiceTest class.

Реентерабельные контекстные менеджеры

Большая часть создаваемых вами контекстных менеджеров может быть написана только для использования с оператором with для одноразового применения. Вот пример:

Python

from contextlib import contextmanager

@contextmanager
def single():
print(‘Yielding’)
yield
print(‘Exiting context manager’)

context = single()
with context:
pass

1
2
3
4
5
6
7
8
9
10
11

fromcontextlibimportcontextmanager

@contextmanager

defsingle()

print(‘Yielding’)

yield

print(‘Exiting context manager’)

context=single()

withcontext

pass

Результат:

Python

Yielding
Exiting context manager

1
2

Yielding

Exiting context manager

Python

with context:
pass

1
2

withcontext

pass

Python

Traceback (most recent call last):
Python Shell, prompt 9, line 1
File «/usr/local/lib/python3.5/contextlib.py», line 61, in __enter__
raise RuntimeError(«generator didn’t yield») from None
builtins.RuntimeError: generator didn’t yield

1
2
3
4
5

Traceback(most recent call last)

Python Shell,prompt9,line1

File»/usr/local/lib/python3.5/contextlib.py»,line61,in__enter__

raiseRuntimeError(«generator didn’t yield»)fromNone

builtins.RuntimeErrorgenerator didn’tyield

Здесь мы создали экземпляр контекстного менеджера и пытаемся запустить его дважды с оператором with. Второй запуск приводит к ошибке RuntimeError. Но что делать, если нам необходимо, чтобы контекстный менеджер запускался дважды? Для этой цели нам и нужен реентрабельный контекстный менеджер. Давайте используем менеджер redirect_stdout, который мы применяли ранее.

Python

from contextlib import redirect_stdout
from io import StringIO

stream = StringIO()
write_to_stream = redirect_stdout(stream)
with write_to_stream:
print(‘Write something to the stream’)
with write_to_stream:
print(‘Write something else to stream’)

print(stream.getvalue())

1
2
3
4
5
6
7
8
9
10
11

fromcontextlibimportredirect_stdout

fromioimportStringIO

stream=StringIO()

write_to_stream=redirect_stdout(stream)

withwrite_to_stream

print(‘Write something to the stream’)

withwrite_to_stream

print(‘Write something else to stream’)

print(stream.getvalue())

Результат

Python

Write something to the stream
Write something else to stream

1
2

Write something to the stream

Write something elseto stream

Здесь мы создали вложенные контекстные менеджеры, которые оба пишут в StringIO, который является текстовым потоком в памяти. Причина, по которой это работает, а не приводит к ошибке RuntimeError, как было ранее в том, что redirect_stdout является реентрабельным и позволяет нам вызывать его дважды. Конечно, ситуации в реальной жизни могут быть заметно сложнее, когда мы работаем с большим количеством функций, которые вызывают друг друга

Пожалуйста, обратите также внимание на то, что контекстные менеджеры не обязательно являются защищенными от потоков. Обратитесь к документации, перед тем как использовать их в потоках во избежание путаницы

Form main template override

Forms are framed by FormWrapper views. It places rendered
form inside Plone page frame. The default FormWrapper is supplied automatically,
but you can override it.

Below is a placeholder example with few inputs.

Example reporter.py:

import zope.schema
import zope.interface
from zope.i18nmessageid import MessageFactory
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile as FiveViewPageTemplateFile

from zope.schema.vocabulary import SimpleVocabulary
from zope.schema.vocabulary import SimpleTerm

import z3c.form

import plone.app.z3cform
import plone.z3cform.templates

_ = MessageFactory('your.addon')


def make_terms(items):
    """ Create zope.schema terms for vocab from tuples """
    terms = , token=pair, title=pair) for pair in items]
    return terms


output_type_vocab = SimpleVocabulary(make_terms())


class IReportSchema(zope.interface.Interface):
    """ Define reporter form fields """
    outputType = zope.schema.Choice(
        title=u"Output type",
        description=u"How do you want the output",
        source=output_type_vocab)

    country = zope.schema.Choice(
        title=u"Country",
        required=False,
        description=u"Which country to report",
        vocabulary="allowed_countries")

    hospital = zope.schema.Choice(
        title=u"Hospital",
        required=False,
        description=u"Which hospital to report",
        vocabulary="allowed_hospitals")


class ReportForm(z3c.form.form.Form):
    """ A form to output a HTML report from chosen parameters """

    fields = z3c.form.field.Fields(IReportSchema)

    ignoreContext = True

    output = None

    @z3c.form.button.buttonAndHandler(_('Make Report'), name='report')
    def report(self, action):
        data, errors = self.extractData()
        if errors:
            self.status = "Please correct errors"
            return

        # Create sample item which we can consume in the page template
        self.output = dict(country="foobar")

        self.status = _(u"Report complete")


# IF you want to customize form frame you need to make a custom FormWrapper view around it
# (default plone.z3cform.layout.FormWrapper is supplied automatically with form.py templates)
report_form_frame = plone.z3cform.layout.wrap_form(ReportForm, index=FiveViewPageTemplateFile("templates/reporter.pt"))

Example configure.zcml:

Example templates/reporter.html:

@EventListener

Next, let us explore how to consume the published events. Starting from version 4.2, Spring supports an annotation-driven event listener – @EventListener.

In particular, we can make use of this annotation to automatically register an ApplicationListener based on the signature of the method :

@EventListener
public void handleContextRefreshEvent(ContextStartedEvent ctxStartEvt) {
    System.out.println("Context Start Event received.");
}

Significantly, @EventListener is a core annotation and hence doesn’t need any extra configuration. In fact, the existing element provides full support to it.

A method annotated with @EventListener can return a non-void type. If the value returned is non-null, the eventing mechanism will publish a new event for it.

3.1. Listening to Multiple Events

Now, there might arise situations where we will need our listener to consume multiple events.

For such a scenario, we can make use of attribute:

@EventListener(classes = { ContextStartedEvent.class, ContextStoppedEvent.class })
public void handleMultipleEvents() {
    System.out.println("Multi-event listener invoked");
}

Краски водно-дисперсионные акрилатные (в качестве покрытия) ТУ 2316-046-43659241-08

Сведения из реестра:

Раздел: Сертификат РФ

Регистрационный номер сертификата соответствия: С-RU.ПБ23.В.00378

Дата начала действия сертификата: 28.03.2013

Дата окончания действия сертификата: 27.03.2015

Основание выдачи сертификата: Отчет об испытаниях № 2495/РИ от 12.03.2013 г. НИЛ ПВБ ООО «НПО ПОЖЦЕНТР», № ТРПБ.RU.ИН28 от 07.10.2010Акт инспекционного контроля № ПБ23.АК.009 от 20.03.2013 ОС НП «ЮУрТО»

Тип заявителя: юридическое лицо

Полное наименование заявителя: Общество с ограниченной ответственностью «Карбон»

Адрес места нахождения заявителя: 426039, г. Ижевск, Воткинское шоссе, 208

Фактический адрес заявителя: 426039, г. Ижевск, Воткинское шоссе, 208

Номер факса заявителя: +73412507607

ОГРН/ОГРНИП заявителя: 1121840008245

Тип изготовителя: юридическое лицо

Полное наименование изготовителя: Общество с ограниченной ответственностью «Карбон»

Адрес места нахождения изготовителя: 426039, г. Ижевск, Воткинское шоссе, 208

Государственный регистрационный номер записи о регистрации юридического лица изготовителя: 1121840008245

Номер факса изготовителя: +73412507607

Тип объекта сертификации: Серийный выпуск

Вид продукции: Отечественная

Полное наименование продукции: Краски водно-дисперсионные акрилатные (в качестве покрытия) ТУ 2316-046-43659241-08

Код по Общероссийскому классификатору продукции (ОКП):

Технический регламент: Технический регламент о требованиях пожарной безопасности (Федеральный Закон N 123 от 22 июля 2008г, в ред. Федеральных законов от 10.07.2012 N 117 Ф3, от 02.07.2013 N 185 Ф3, от 23.06.2014 N 160 ФЗ, от 13.07.2015 N 234 ФЗ, от 03.07.2016 N 301 ФЗ, 29.07.2017 N 244 ФЗ)

Обозначение национального стандарта или свода правил: см. приложение бланк № 0137752

Обозначение национального стандарта или свода правил(приложение): ГОСТ 30244-94;ГОСТ 30402-96;ГОСТ 12.1.044-89 (ИСО 4589-84);ГОСТ 12.1.044-89 (ИСО 4589-84)

Наименование национального стандарта или свода правил (приложение): Материалы строительные. Методы испытаний на горючесть;Материалы строительные. Метод испытания на воспламеняемость;Система стандартов безопасности труда.Пожаровзрывоопасность веществ и материалов. Номенклатура показателей и методы их определения;Система стандартов безопасности труда.Пожаровзрывоопасность веществ и материалов. Номенклатура показателей и методы их определения

Подтверждение требованиям национального стандарта или свода правил (приложение): Слабогорючие (Г1);Трудновоспламеняемые (В1);С малой дымообразующей способностью (Д1);По токсичности продуктов горения малоопасные (Т1)

Номер аттестата органа по сертификации: ССПБ.RU.ПБ23

Юридический адрес органа по сертификации: 456318, Челябинская область, г. Миасс, пр. Октября, 66

Дата регистрации аттестата: 23.04.2009

Фамилия Имя Отчество эксперта: Воронина Наталья Николаевна

Ссылка на основную публикацию