$(document).ready(function(){
  $("p").click(function(){
    $(this).hide();
  });
});

<span id="{{ id }}" class="button-delete {{ class_name }}">
	<span class="icon icon-delete-trash"></span>
	{{text}}
</span>

{
    "widget":{
        "name":"My Widget",
        "short_description":"Short description",
        "description":"Full description",
        "tour_description":"Tour description"
    }
}

{
    "widget":{
				"name":"Mi Widget",
        "short_description":"Descripción breve",
        "description":"Descripción completa",
        "tour_description":"Descripción del Tour"
    }
}

{
    "widget":{
				"name":"Meu widget",
        "short_description":"Descrição curta",
        "description":"Descrição completa",
        "tour_description":"Descrição de tour"
    }
}

define(['jquery'], function ($) {
  'use strict';

  return function () {
    var self = this;

    this.callbacks = {
      render: function () {
        return true;
      },

      init: function () {
        return true;
      },

      bind_actions: function () {
        return true;
      },

      settings: function () {
        var $modal_body = $('.modal.' + self.get_settings().widget_code + ' .modal-body'),
            $widget_settings = $modal_body.find('.widget_settings_block');

        $widget_settings.html(
          self.render({ ref: '/tmpl/controls/button.twig' }, {
            text: 'Button'
          })
        );

        return true;
      },

      onSave: function () {
        return true;
      }
    };
  };
});

{
  "widget": {
    "name": "widget.name",
    "description": "widget.description",
    "short_description": "widget.short_description",
    "version": "1.0.1",
    "interface_version": 2,
    "init_once": false,
    "locale": [
      "en",
      "pt",
      "es"
    ],
    "installation": true,
    "support": {
      "link": "https://kommo.com",
      "email": "[email protected]"
    }
  },
  "locations": [
    "settings",
    "lcard-1",
    "ccard-0"
  ],
  "tour": {
    "is_tour": true,
    "tour_images": {
      "en": [
        "/images/slideshow_1_en.jpg",
        "/images/slideshow_2_en.jpg",
        "/images/slideshow_3_en.jpg"
      ],
      "es": [
        "/images/slideshow_1_es.jpg",
        "/images/slideshow_2_es.jpg",
        "/images/slideshow_3_es.jpg"
      ],
      "pt": [
        "/images/slideshow_1_pt.jpg",
        "/images/slideshow_2_pt.jpg",
        "/images/slideshow_3_pt.jpg"
      ]
    },
    "tour_description": "widget.tour_description"
  },
  "settings": {
    "custom": {
      "name": "settings.custom",
      "type": "custom",
      "required": false
    }
  }
}

"widget": {
    "name": "widget.name",
    "description": "widget.description",
    "short_description": "widget.short_description",

 "version": "1.0.1",
    "interface_version": 2,
    "init_once": false,

"locale": [
      "en",
      "pt",
      "es"
    ],

 "installation": true,
    "support": {
      "link": "https://kommo.com",
      "email": "[email protected]"
    }
  },

"locations": [
    "settings",
    "lcard-1",
    "ccard-0"
  ],

"tour": {
    "is_tour": true,
    "tour_images": {
      "en": ["/images/slideshow_1_en.jpg", "/images/slideshow_2_en.jpg", "/images/slideshow_3_en.jpg"],
      "es": ["/images/slideshow_1_es.jpg", "/images/slideshow_2_es.jpg", "/images/slideshow_3_es.jpg"],
      "pt": ["/images/slideshow_1_pt.jpg", "/images/slideshow_2_pt.jpg", "/images/slideshow_3_pt.jpg"]
    },
    "tour_description": "widget.tour_description"
  }

 "settings": {
    "custom": {
      "name": "settings.custom",
      "type": "custom",
      "required": false
    }
  }
}

{
  "widget": {
    "name": "Birthday",
    "short_description": "Happy Birthday widget",
    "description": "The Happy Birthday widget assigns a task on a client's birthday, so you never miss an important date.",
    "tour_description": "Happy Birthday widget"
  },
  "settings": {
    "custom": "Settings",
    "options": {
      "title": "Settings",
      "desc": "Set up the form for creating a new task"
    },
    "base": "Automatically create tasks within a selected profile when it's your client's birthday.",
    "not_active": "Install the widget to begin setup.",
    "lead": "Lead",
    "contact": "Contact",
    "field": {
      "title": "Birthday field",
      "desc": "Select a field that contains the birthday date",
      "tip": "Select a field type \"date\", \"birthday\" or \"date and time\", or create a new field by clicking \"Add new field\"",
      "or": "or",
      "create": "Add new field"
    },
    "entity": {
      "options": {
        "contact": "Contact",
        "lead": "Lead"
      }
    },
    "type": {
      "title": "Task type",
      "desc": "Select the type of task to assign"
    },
    "responsible": {
      "title": "Responsible user",
      "desc": "Assign a user responsible for this task",
      "select": "Select users",
      "numeral": "user,user,users",
      "current": "Current responsible user"
    },
    "text": {
      "title": "Task description",
      "desc": "Write the description or leave the field empty",
      "placeholder": "Task description..."
    },
    "template": {
      "title": "Chat templates",
      "desc": "Create a chat template to send to your clients",
      "name": {
        "title": "Template name",
        "desc": "Enter the template name that will be shown in the profile"
      },
      "text": {
        "title": "Message text",
        "desc": "Write the message text that will be sent to the client",
        "placeholder": "Message..."
      },
      "list": {
        "title": "List of created templates"
      },
      "create": "Create a template"
    },
    "errors": {
      "template_fields_required": "Enter the template name and message text to continue."
    },
    "modal": {
      "title": "Create new Birthday field",
      "name": {
        "title": "Name of the field",
        "desc": "Enter name of the field"
      },
      "entity": {
        "title": "Type of object",
        "desc": "Select type of object"
      },
      "success_saved": "New Birthday field was successfully created.",
      "create": "Create a field"
    },
    "widget_panel": {
      "birthday": "Today is your client's birthday!",
      "not_birthday": "No birthdays today. Check back tomorrow!",
      "congratulate": "Send a birthday wish"
    }
  }
}

define(
  [
    './classes/template.js',
    './classes/loader.js',
    './classes/kommo.js',
    './classes/events.js',
    './classes/settings.js',
    './plugins/jquery.serializejson.min.js',
  ]

return class Cache {
      constructor () {
        window.KommoWidget.cache = window.KommoWidget.cache || {}
      }

kbd_account :
{
  payload: {
    id: number; //account ID
    name: string; //account name
    subdomain: string;
    created_at: number; //unix timeStamp
    created_by: number;
    updated_at: number; //unix timeStamp
    updated_by: number;
    current_user_id: number;
    country: string;
    currency: string;
    currency_symbol: string;
    customers_mode: string;
    is_unsorted_on: boolean;
    mobile_feature_version: number;
    is_loss_reason_enabled: boolean;
    is_helpbot_enabled: boolean;
    is_technical_account: boolean;
    contact_name_display_order: number;
    _links: { self: { href: string } }; // GET request to account
    _embedded: {
      task_types: [
        {
          id: number;
          name: string;
          color: null;
          icon_id: null;
          code: string;
        }
      ];
    };
  };
  expires: number; //unix timeStamp
}

getItem(key) {
      let result;
      if (window.KommoWidget.cache[key]) {
        result = window.KommoWidget.cache[key];
      } else {
        let cache = JSON.parse(window.sessionStorage.getItem(key) || null);
        if (cache !== null && cache.expires <= Math.floor(Date.now() / 1000)) {
          window.sessionStorage.removeItem(key);
        }

        result = (cache || {}).payload || null;
      }
      return result;
    }

setItem(key, value, expires, local) {
      if (local) {
        window.KommoWidget.cache[key] = value;
      } else {
        window.sessionStorage.setItem(
          key,
          JSON.stringify({
            payload: value,
            expires: Math.floor(Date.now() / 1000) + expires,
          })
        );
      }
    }

removeItem (key) {
        window.sessionStorage.removeItem(key)
      }

define(
  [
    './cache.js'
  ],

request(type, payload, method, options = {}) {
      let cache = new Cache();
      return new Promise(function (resolve, reject) {
        let data = null;
        if (options.cache) {
          data = cache.getItem(options.cache.key);
        }

        if (!data) {
          $.ajax({
            url: options.baseURL + type,
            data: payload,
            method: method,
            beforeSend: function (xhr) {
              xhr.withCredentials = true;
            },
            headers: options.headers || {},
          })
            .done(function (data) {
              resolve(data);
            })
            .fail(function (resp) {
              reject(resp);
            });
        } else {
          resolve(data);
        }
      }).then(function (data) {
        return new Promise(function (resolve) {
          if (options.embedded && (data || {})["_embedded"]) {
            data = (data || {})["_embedded"][options.embedded] || [];
          }

          if (options.cache && data) {
            cache.setItem(
              options.cache.key,
              data,
              options.cache.expires,
              options.cache.local || false
            );
          }

          if (options.rk) {
            data = (data || {})[options.rk] || null;
          }

          resolve(data);
        });
      });
    }

define(
  [
    './http.js',
  ],

getAccount() {
      return this.http.request(
        "/api/v4/account",
        { with: "task_types" },
        "GET",
        {
          cache: { key: "kbd_account", expires: 60 },
          baseURL: window.location.origin,
        }
      );
    }

getTasks(filter) {
      return this.http
        .request(
          "/api/v4/tasks",
          {
            filter: filter,
          },
          "GET",
          {
            baseURL: window.location.origin,
          }
        )
        .then(function (data) {
          return ((data || {})._embedded || {}).tasks || [];
        });
    }

createTask(payload) {
      return this.http
        .request("/api/v4/tasks", JSON.stringify([payload]), "POST", {
          baseURL: window.location.origin,
        })
        .then(function (data) {
          return ((data || {})._embedded || {}).tasks || [];
        });
    

createField(et, payload) {
      let _this = this;
      return _this.http
        .request(
          "/api/v4/" + et + "/custom_fields",
          JSON.stringify([payload]),
          "POST",
          {
            baseURL: window.location.origin,
            headers: {
              "Content-Type": "application/json",
            },
          }
        )
        .then(function (data) {
          return (((data || {})._embedded || {}).custom_fields || [])[0] || {};
        });
    }

createTemplate(payload) {
      return this.http
        .request(
          "/ajax/v1/chats/templates/add",
          JSON.stringify({
            request: payload,
          }),
          "POST",
          {
            baseURL: window.location.origin,
            headers: {
              "Content-Type": "application/json",
            },
          }
        )
        .then(function (data) {
          return (
            ((((data || {}).response || {}).chats || {}).templates || {})
              .added || 0
          );
        });
    }

getTemplates() {
      return this.http
        .request(
          "/ajax/v4/chats/templates",
          {
            with: "integration,reviews",
            limit: 50,
            page: 1,
          },
          "GET",
          {
            baseURL: window.location.origin,
          }
        )
        .then(function (data) {
          return ((data || {})._embedded || {}).chat_templates || {};
        });
    }

getUsers(users = [], page = 1) {
      let _this = this;
      return this.http
        .request(
          "/api/v4/users",
          {
            limit: 100,
            page: page,
          },
          "GET",
          {
            baseURL: window.location.origin,
          }
        )
        .then(function (data) {
          return new Promise((resolve) => {
            let tmp = ((data || {})._embedded || {}).users || [];
            tmp.forEach(function (user) {
              if (user.rights.is_active) {
                users.push({
                  id: user.id,
                  option: user.name,
                  name: user.name,
                  is_admin: user.rights.is_admin,
                });
              }
            });

            if (data._page_count > 1 && data._page < data._page_count) {
              resolve(_this.getUsers(users, page + 1));
            } else {
              resolve(users);
            }
          });
      

getTaskTypes() {
      let _this = this;
      return this.getAccount().then(function (account) {
        let types = ((account || {})._embedded || {}).task_types || {};
        types = Object.values(types).filter(function (item) {
          item.option = item.name;
          return item;
        });
        return types;
      });
    }

 getFields(et, page = 1, fields = []) {
      let _this = this;
      return _this.http
        .request(
          "/api/v4/" + et + "/custom_fields",
          {
            page: page,
          },
          "GET",
          {
            baseURL: window.location.origin,
          }
        )
        .then(function (data) {
          let cf = ((data || {})._embedded || {}).custom_fields || [];
          if (cf.length === 0) {
            return fields;
          }

          fields = fields.concat(cf);
          if (((data || {})._page_count || 0) > 1) {
            page++;
            return _this.getFields(et, page, fields);
          } else {
            return fields;
          }
        });
    }

getEmptyPromise() {
      return new Promise(function (resolve) {
        resolve([]);
      });
    }

getFieldsByType(fieldTypes, entityType = null, addPostfix = false) {
      let _this = this;
      let entityTypes = [];
      if (entityType) {
        entityTypes = !Array.isArray(entityType) ? [entityType] : entityType;
      }

      return Promise.all([
        $.inArray(APP.element_types.leads, entityTypes) >= 0
          ? _this.getFields("leads")
          : _this.getEmptyPromise(),
        $.inArray(APP.element_types.contacts, entityTypes) >= 0
          ? _this.getFields("contacts")
          : _this.getEmptyPromise(),
      ]).then(function ([leadFields, contactFields]) {
        let fields = [];

        if (!Array.isArray(fieldTypes)) {
          fieldTypes = [fieldTypes];
        }

        entityTypes.forEach(function (et) {
          let cf = {};
          let postfix = "";
          switch (et) {
            case APP.element_types.contacts:
              cf = contactFields;
              postfix += " (" + _this.widget.i18n("settings.contact") + ")";
              break;
            case APP.element_types.leads:
              cf = leadFields;
              postfix += " (" + _this.widget.i18n("settings.lead") + ")";
              break;
          }

          if (!addPostfix) {
            postfix = "";
          }

          if (cf.length > 0) {
            cf.forEach(function (field) {
              if (
                APP.cf_types[field.type] &&
                $.inArray(APP.cf_types[field.type], fieldTypes) >= 0
              ) {
                fields.push({
                  id: field.id,
                  code: (field.code || "").toLowerCase(),
                  sort: field.sort,
                  option: field.name + postfix,
                  type: APP.cf_types[field.type],
                  entity_type: et,
                  parent_id: 0,
                  enums: field.enums || [],
                  is_hidden: false,
                });
              }
            });
          }
        });

        return fields;
      });
    }

define(
  [
    'moment',
    'lib/components/base/modal',
  ],

settings() {
      let _this = this;
      const MODAL_DESTROY_TIMEOUT = 3000;

      $(".kommo-birthday__field-create__link").on("click", function () {
        let modal = _this.widget.templates.twig.modal(
          _this.widget.templates.render("settings.modal", {
            prefix: _this.widget.config.prefix,
            langs: _this.widget.i18n("settings.modal"),
            name: _this.widget.templates.twig.input({
              block: "field",
              code: "name",
            }),
            entity: _this.widget.templates.twig.select({
              block: "field",
              code: "entity",
              items: [
                {
                  id: APP.element_types.contacts,
                  option: _this.widget.i18n("settings.entity.options.contact"),
                },
                {
                  id: APP.element_types.leads,
                  option: _this.widget.i18n("settings.entity.options.lead"),
                },
              ],
              selected: APP.element_types.contacts,
            }),

            button: _this.widget.templates.twig.button({
              block: "field",
              code: "btn",
              text: _this.widget.i18n("settings.modal.create"),
            }),
          }),

          function () {},
          _this.widget.config.prefix + "__field-modal"
        );

        $("#" + _this.widget.config.prefix + "-field-btn-id").on(
          "click",

          function () {
            const resultModal = new Modal();

            let selected = {};
            let form =
              $(
                "#" + _this.widget.config.prefix + "__field-form"
              ).serializeJSON().params || {};
            let et = parseInt(form.field.entity) === 1 ? "contacts" : "leads";

            _this.widget.kommo
              .createField(et, {
                type: "birthday",
                name: form.field.name,
              })
              .then(function (result) {
                selected = result;

                return _this.widget.kommo.getFieldsByType(
                  [
                    APP.cf_types.date,
                    APP.cf_types.date_time,
                    APP.cf_types.birthday,
                  ],
                  [APP.element_types.contacts, APP.element_types.leads],
                  true
                );
              })
              .then(function (fields) {
                $("." + _this.widget.config.prefix + "__field-id").replaceWith(
                  _this.widget.templates.twig.select({
                    block: "field",
                    code: "id",
                    items: fields,
                    selected: selected.id || 0,
                  })
                );

                modal.destroy();

                resultModal.showSuccess(
                  _this.widget.i18n("settings.modal.success_saved"),
                  false,
                  MODAL_DESTROY_TIMEOUT
                );
              })
              .catch(() => {
                resultModal.showError("", false);
              });
          }
        );
      });

      if (_this.widget.info.params.templates.length > 0) {
        let created = _this.widget.info.params.templates.split(",");
        $("#kommo-birthday-templates-list").val(
          _this.widget.info.params.templates || ""
        );
        _this.widget.kommo.getTemplates().then(function (templates) {
          created = created.map(function (item) {
            return parseInt(item);
          });
          templates.filter(function (item) {
            if ($.inArray(item.id, created) > -1) {
              $("#kommo-birthday-templates-list-ul").append(
                "<li>" + item.name + "</li>"
              );
            }
          });
        });
      }

      $("#kommo-birthday-template-create-id").on("click", function () {
        let name = $("#kommo-birthday-template-name-id").val();
        let text = $("#kommo-birthday-template-text-id").val();

        if (name.length === 0 || text.length === 0) {
          new Modal().showError(
            _this.widget.i18n("settings.errors.template_fields_required"),
            false
          );
        } else {
          _this.widget.kommo
            .createTemplate({
              name: name,
              reply_name: name,
              content: text,
              reply_text: text,
              is_editable: true,
              type: "amocrm",
              attachments: [],
              buttons: [],
              widget_code: null,
              client_uuid: null,
              creator_logo_url: null,
              waba_footer: null,
              waba_category: null,
              waba_language: null,
              waba_examples: {},
              reviews: null,
              waba_header: null,
              waba_selected_waba_ids: [],
            })
            .then(function (id) {
              if (parseInt(id) > 0) {
                $("#kommo-birthday-template-text-id").val("");
                $("#kommo-birthday-template-name-id").val("");

                let old = $("#kommo-birthday-templates-list").val().split(",");
                old.push(id);
                old = old.filter(function (item) {
                  return parseInt(item) > 0;
                });
                $("#kommo-birthday-templates-list").val(old.join(","));
                $("#kommo-birthday-templates-list-ul").append(
                  "<li>" + name + "</li>"
                );
              }
            });
        }
      });
    }

getBirthdayInfo() {
      const fieldId = parseInt(
        this.widget.getNested(this.widget.info.params, "field.id", "")
      );

      const $wrap = $('.linked-form__field[data-id="' + fieldId + '"]');
      const filtered = $wrap.filter(function () {
        const formattedDate = Moment().format(
          APP.system.format.date.date_short
        );
        const dayMonth = $(this).find("input").val().slice(0, -5);

        return dayMonth === formattedDate;
      });

      const currentDate = Moment().format(APP.system.format.date.date);

      return {
        isBirthday: filtered.length > 0,
        currentDate: currentDate,
      };
    }

card() {
      const _this = this;

      const { isBirthday } = _this.getBirthdayInfo();

      if (isBirthday) {
        let entityType = parseInt(
          _this.widget.getNested(_this.widget.info.params, "entity.type", 2)
        );

        let responsibles = _this.widget.getNested(
          _this.widget.info.params,
          "tasks.responsible",
          {}
        );

        if (responsibles[1]) {
          responsibles[APP.data.current_card.main_user] =
            APP.data.current_card.main_user;
        }

        if (
          entityType === parseInt(APP.data.current_card.element_type) &&
          responsibles[APP.constant("user").id]
        ) {
          _this.createTask(isBirthday);
        }
      }
    }

createTask(isBirthday) {
      const _this = this;

      let { currentDate } = _this.getBirthdayInfo();

      if (isBirthday) {
        const taskType = parseInt(
          _this.widget.getNested(_this.widget.info.params, "tasks.type", 1)
        );

        _this.widget.kommo
          .getTasks({
            is_completed: 0,
            entity_type: APP.data.current_entity,
            entity_id: APP.data.current_card.id,
            task_type: taskType,
          })
          .then(function (tasks) {
            if (tasks.length === 0) {
              _this.widget.kommo.createTask({
                responsible_user_id: APP.constant("user").id,
                entity_id: APP.data.current_card.id,
                entity_type: "leads",
                task_type_id: taskType,
                text: _this.widget.getNested(
                  _this.widget.info.params,
                  "tasks.text",
                  "-"
                ),

                complete_till: Moment(
                  (currentDate += " 23:59"),
                  APP.system.format.date.full
                ).unix(),
              });
            }
          });
      }
    }

prepend (elem) {
        elem.prepend(this.getHtml())
        return this
      }

getHtml() {
        let _this = this
        if (_this.html.length === 0) {
          _this.html = _this.templates.render(
            'loader',
            {
              widget: _this.langs.widget.name,
              icons: _this.widget.config.icons,
            },
          )
        }

        return _this.html
      }

hide () {
        return $('.kommo-loader').hide()
      }

show () {
        $('.kommo-loader').show()
        return this
      }

remove () {
        $('.kommo-loader').remove()
        return this
      }

displaySaveBtn(code) {
      $(".modal." + code)
        .find(".widget_settings_block__controls")
        .show();
      return this;
    }

save (evt) {
        let _this = this
        let code = _this.widget.params.widget_code
        let isActive = false
        let params = ($('#' + _this.widget.config.prefix + '-settings__form').serializeJSON() || {}).params || {}

        return new Promise(function (resolve, reject) {
          isActive = evt.active === 'Y'

          let data = {
            is_active: isActive,
          }

          let installed = ((_this.widget.params || {}).active || 'N') === 'Y'
          if (!installed) {
            resolve({ 'reinstall': true })
          }

          if (isActive) {
            if (!_this.widget.validateSettings(params)) {
              $('.modal.' + code).
                find('.js-widget-save').
                trigger('button:save:error')

              reject()
            } else {
              data.params = params
            }
          }

          _this.widget.info = data
          evt.fields.custom = JSON.stringify(params)
          resolve(data)
        }).then(function () {
          return true
        })
      }

load () {
        let _this = this
        return new Promise((resolve, reject) => {
          _this.widget.info.params = (_this.widget.params || {}).custom || {}
          if (typeof _this.widget.info.params === 'string') {
            _this.widget.info.params = JSON.parse(_this.widget.info.params)
          }

          if (!_this.widget.info.params.templates) {
            _this.widget.info.params.templates = ''
          }
          resolve([])
        })
      }

define(
  [
    'jquery',
    'lib/components/base/modal',
    'twigjs',
    'text',
  ]

flushTextPlugin () {
        text.useXhr = function () {
          return true
        }
      }

restoreTextPlugin () {
        text.useXhr = this.textSavedXhr
      }

checkRegistry (name) {
        let id = 'kommo_bd_' + name
        return !!(Twig.Templates || {}).registry[id]
      }

getFromRegistry (name) {
        let id = 'kommo_bd_' + name
        return (Twig.Templates || {}).registry[id] || ''
      }

preload () {
        return Promise.all([
            this.loadCss(),
            this.loadTemplates(),
          ],
        )
      }

loadTemplates() {
      let _this = this;
      return new Promise(function (resolve) {
        let area = APP.widgets.system.area;
        let templates = _this.templates.params[area] || [];
        _this.flushTextPlugin();
        if (templates.length > 0) {
          let load = [];
          let ids = [];
          templates.forEach(function (template) {
            if (template.id.indexOf(_this.widget.config.code) === -1) {
              template.id = _this.widget.config.code + "_" + template.id;
            }

            if (!template.url) {
              template.url =
                _this.widget.params.path +
                "/assets/templates" +
                template.path +
                ".twig?v=" +
                _this.widget.get_version();
            }

            if (!_this.checkRegistry(template.id)) {
              load.push("text!" + template.url);
              ids.push(template.id);
            } else {
              _this.templates.html[template.id] = _this.getFromRegistry(
                template.id
              );
            }
          });

          if (load.length > 0) {
            require(load, function () {
              for (let i = 0; i < arguments.length; i++) {
                _this.addTemplate(ids[i], arguments[i]);
              }
              resolve();
            });
          } else {
            resolve();
          }
        } else {
          resolve();
        }
      });
    }

addTemplate(name, data) {
      let id = "kommo_bd_" + name;
      if (this.checkRegistry(name)) {
        this.templates.html[name] = Twig.Templates.registry[id];
        return;
      }

      this.templates.html[name] = twig({
        id: id,
        data: data,
        allowInlineIncludes: true,
      });
    }

loadCss() {
      let _this = this;
      return new Promise(function (resolve) {
        let html = "";
        _this.css.forEach((file) => {
          let $style = null;
          let path =
            _this.widget.params.path +
            "/assets/css/" +
            file.name +
            ".css?v=" +
            _this.widget.params.version;
          if (file.append_id) {
            $style = $("#" + file.append_id);
          } else {
            $style = $('link[href="' + path + '"]');
          }

          if ($style.length < 1) {
            html +=
              '<link type="text/css" rel="stylesheet" href="' + path + '"';
            if (file.append_id) {
              html += ' id="' + file.append_id + '"';
            }
            html += ">";
          }
        });

        if (html.length > 0) {
          $("head").append(html);
        }

        resolve();
      });
    }

render(name, params) {
      name = this.widget.config.code + "_" + name;
      return this.templates.html[name].render(params || {});
    }

installPlaceholder(wrapDiv, exception = null) {
      let params = {
        prefix: this.widget.config.prefix,
        langs: this.widget.i18n("settings"),
        active: false,
      };

      if (exception !== null) {
        params.exception = exception;
      }

      wrapDiv.prepend(this.render("settings.base", params));
      $("#kommo-settings").fadeIn(300);
      this.widget.loader.displaySaveBtn(this.widget.params.widget_code);
      return this.widget.loader.hide();
    }

.kommo__tooltip-wrap:hover .kommo-holdings__settings__tooltip {
    visibility: visible !important;
    opacity: 1 !important;
}

.kommo__tooltip-wrap:hover .kommo__settings__tooltip, .kommo__tooltip-wrap--icon:hover .kommo__settings__tooltip {
    visibility: visible !important;
    opacity: 1 !important;
}

responsible: _this.templates.twig.dropdown({
                        block: 'tasks',
                        code: 'responsible',
                        title_empty: _this.i18n('settings.responsible.select'),
                        title_numeral: _this.i18n(
                          'settings.responsible.numeral'),
                        name_is_array: true,
                        items: users.filter(function (user) {
                          user.name = 'params[tasks][responsible][' + user.id + ']'
                          user.is_checked = !!(_this.getNested(
                              _this.info.params,
                              'tasks.responsible', {})[user.id]
                          )
                          return user
                        }),

.then(() => {
              $(".kommo-birthday__button-congratulate").on(
                "click",
                function () {
                  setTimeout(function () {
                    $(".feed-compose__quick-actions-wrapper").click();
                  }, QUICK_ACTIONS_CLICK_TIMEOUT);
                }
              );
            });