diff --git a/diagrams/msls-package.puml b/diagrams/msls-package.puml new file mode 100644 index 00000000..9bc4a1e5 --- /dev/null +++ b/diagrams/msls-package.puml @@ -0,0 +1,48 @@ +@startuml package-related-diagram + package lloc.Msls as Msls { + package ContentImport { + package LogWriters { + } + package Importers { + package PostMeta { + } + package PostThumbnail { + } + package Terms { + } + package PostFields { + } + package Attachments { + } + } + } + package Component { + package Input { + } + package Icon { + } + } + package Map { + } + package Query { + } + } + Msls --> Input + Msls <-[#red,plain,thickness=4]-> Query + Msls <-[#red,plain,thickness=4]-> Map + Msls <-[#red,plain,thickness=4]-> ContentImport + Msls <-[#red,plain,thickness=4]-> Icon + ContentImport <-[#red,plain,thickness=4]-> Importers + ContentImport <-[#red,plain,thickness=4]-> LogWriters + LogWriters --> Msls + Importers <-[#red,plain,thickness=4]-> PostFields + Importers --> Msls + Importers <-[#red,plain,thickness=4]-> Terms + Importers <-[#red,plain,thickness=4]-> PostThumbnail + Importers <-[#red,plain,thickness=4]-> PostMeta + Importers <-[#red,plain,thickness=4]-> Attachments + PostThumbnail --> ContentImport + Terms --> Msls + Input --> Component + Icon --> Component +@enduml diff --git a/diagrams/mslsl-class.puml b/diagrams/mslsl-class.puml new file mode 100644 index 00000000..0105199e --- /dev/null +++ b/diagrams/mslsl-class.puml @@ -0,0 +1,987 @@ +@startuml class-diagram + class "MslsCustomColumnTaxonomy\nHandling of existing/not existing translations in the backend" as MslsCustomColumnTaxonomy { + {static} +init() + +column_default(deprecated, column_name, item_id) + +delete(object_id) + } + class "MslsCustomFilter\nAdding custom filter to posts/pages table." as MslsCustomFilter { + {static} +init() + +add_filter() + +execute_filter(query) + } + class "MslsBlock" as MslsBlock { + #options : MslsOptions + +__construct(options) + {static} +init() + +register_block() + } + class "MslsOptionsQuery\nMslsOptionsQuery" as MslsOptionsQuery { + +with_front : bool + #sql_cache : MslsSqlCacher + +__construct(sql_cache) + {static} +get_params() + {static} +create(id) + +get_postlink(language) + } + class "MslsContentTypes\nSupported content types" as MslsContentTypes { + #request : string + #types : array + {static} +create() + +is_post_type() + +is_taxonomy() + +acl_request() + {static} {abstract} +get() + {abstract} +get_request() + } + class "MslsOptionsQueryMonth\nMslsOptionsQueryMonth" as MslsOptionsQueryMonth { + #year : int + #monthnum : int + +__construct(sql_cache) + {static} +get_params() + +has_value(language) + +get_current_link() + } + class "MslsTaxonomy\nContent types: Taxonomies (Tags, Categories, ...)" as MslsTaxonomy { + #post_type : string + +__construct() + {static} +get() + +get_request() + +is_taxonomy() + +acl_request() + +get_post_type() + } + class "MslsPostTagClassic\nPost Tag Classic" as MslsPostTagClassic { + +add_input(taxonomy) + +edit_input(tag, taxonomy) + +the_input(tag, title_format, item_format) + +print_option(blog, type, mydata, item_format) + } + class "MslsPostType\nContent types: Post types (Pages, Posts, ...)" as MslsPostType { + +__construct() + {static} +get() + +get_request() + +is_post_type() + } + class "MslsPostTag\nPost Tag" as MslsPostTag { + {static} +suggest() + {static} +init() + +add_input(taxonomy) + +edit_input(tag, taxonomy) + +the_input(tag, title_format, item_format) + +set(term_id) + +maybe_set_linked_term(mydata) + #get_select_title() + } + class "MslsLanguageArray\nStores the language input from post" as MslsLanguageArray { + #arr : array + +__construct(arr) + +set(key, value) + +get_val(key) + +get_arr(key) + } + class "MslsOutput\nOutput in the frontend" as MslsOutput { + #tags : array + +get(display, filter, exists) + +get_alternate_links() + +__toString() + +get_tags() + +set_tags(arr) + +is_requirements_not_fulfilled(thing, exists, language) + } + class "MslsWidget\nThe standard widget of the Multisite Language Switcher" as MslsWidget { + +id_base : + +__construct() + {static} +init() + +widget(args, instance) + +update(new_instance, old_instance) + +form(instance) + } + class "MslsAdmin\nAdministration of the options" as MslsAdmin { + {static} +init() + +get_menu_slug() + +get_options_page_link() + +__call(method, args) + +has_problems() + +render() + +subsubsub() + +register() + +language_section() + +main_section() + +advanced_section() + +rewrites_section() + #add_settings_fields(map, section) + +blog_language() + +display() + +admin_display() + +reference_user() + +description() + +content_priority() + +render_rewrite(key) + +validate(arr) + +set_blog_language(arr) + } + class "MslsLinkImageOnly\nLink type: Image only" as MslsLinkImageOnly { + #format_string : string + {static} +get_description() + } + class "MslsMetaBox\nMeta box for the edit mode of the (custom) post types" as MslsMetaBox { + {static} +suggest() + {static} +get_suggested_fields(json, args) + {static} +init() + +add() + +render_select() + +render_options(type, msls_id) + +render_option(post_id, msls_id) + +render_input(echo) + +set(post_id) + +maybe_set_linked_post(mydata) + } + class "MslsLinkTextImage\nLink type: Text and image" as MslsLinkTextImage { + #format_string : string + {static} +get_description() + } + class "MslsBlog\nInternal representation of a blog" as MslsBlog { + -obj : StdClass + -language : string + -description : string + +__construct(obj, description) + +__get(key) + +get_description() + +get_title(icon_type) + +get_language(default) + +get_alpha2() + +get_url(options) + #get_permalink(options) + {static} +_cmp(a, b) + {static} +language(a, b) + {static} +description(a, b) + +get_blavatar() + } + class "MslsOptionsTaxTermCategory\nMslsOptionsTaxTermCategory" as MslsOptionsTaxTermCategory { + } + class "MslsOptionsQueryPostType\nMslsOptionsQueryPostType" as MslsOptionsQueryPostType { + #post_type : string + +__construct(sql_cache) + {static} +get_params() + +has_value(language) + +get_current_link() + } + class "MslsOptionsPost\nPost options" as MslsOptionsPost { + #sep : string + #autoload : string + +get_postlink(language) + +get_current_link() + } + class "MslsAdminIcon\nHandles the icon links in the backend" as MslsAdminIcon { + #icon_type : string + #language : string + +origin_language : string + #src : string + #href : string + #blog_id : int + #type : string + #path : string + #id : int + +__construct(type) + +__toString() + {static} +create(type) + +set_icon_type(icon_type) + +set_path() + +set_language(language) + +set_src(src) + +set_href(id) + +set_id(id) + +set_origin_language(origin_language) + +get_img() + +get_a() + +get_icon() + +get_edit_new() + } + class "MslsOptionsTax\nMslsOptionsTax" as MslsOptionsTax { + #sep : string + #autoload : string + {static} +create(id) + +get_tax_query() + +get_postlink(language) + +get_current_link() + +get_term_link(term_id) + } + class "MslsRegistryInstance\nClass MslsRegistryInstance" as MslsRegistryInstance { + {static} +instance() + } + class "MslsOptionsQueryDay\nMslsOptionsQueryDay" as MslsOptionsQueryDay { + #year : int + #monthnum : int + #day : int + +__construct(sql_cache) + {static} +get_params() + +has_value(language) + +get_current_link() + } + class "MslsRegistry\nRegistry instead of singletons" as MslsRegistry { + {static} -arr : string[] + {static} -instance : MslsRegistry + -get(key) + -set(key, instance) + {static} +instance() + {static} +get_object(key) + {static} +set_object(key, instance) + } + class "MslsCustomColumn\nHandling of existing/not existing translations in the backend listings of" as MslsCustomColumn { + {static} +init() + +th(columns) + +td(column_name, item_id) + } + class "MslsGetSet\nGeneric class for overloading properties" as MslsGetSet { + #arr : array + +__set(key, value) + +__get(key) + +__isset(key) + +__unset(key) + +reset() + +has_value(key) + +is_empty() + +get_arr() + } + class "MslsShortCode" as MslsShortCode { + #options : MslsOptions + +__construct(options) + {static} +init() + +render_widget() + } + class "MslsSqlCacher\nWrapper to avoid direct SQL without caching" as MslsSqlCacher { + #db : wpdb + #cache_key : string + #expire : int + +__construct(db, cache_key, expire) + {static} +create(caller, params, expire) + +__get(name) + +__call(method, args) + } + class "MslsOptionsQueryYear\nOptionsQueryYear" as MslsOptionsQueryYear { + #year : int + +__construct(sql_cache) + {static} +get_params() + +has_value(language) + +get_current_link() + } + class "MslsFields" as MslsFields { + } + class "MslsOptionsTaxTerm\nMslsOptionsTaxTerm" as MslsOptionsTaxTerm { + +with_front : bool + +check_base(url, options) + {static} #get_base_defined(tax_query) + {static} #get_base_option() + } + class "MslsPlugin\nProvides functionalities for general hooks and activation/deactivation" as MslsPlugin { + #options : MslsOptions + +__construct(options) + {static} +init() + {static} +get_output() + {static} +print_alternate_links() + +custom_enqueue() + {static} +plugins_url(path) + {static} +plugin_dir_path(path) + {static} +dirname(path) + {static} +file() + {static} +path() + +init_i18n_support() + {static} +message_handler(message, css_class) + {static} +activate() + {static} +uninstall() + {static} +cleanup() + } + class "MslsContentFilter" as MslsContentFilter { + #options : MslsOptions + +__construct(options) + {static} +init() + +content_filter(content) + +filter_string(pref, post) + } + class "MslsBlogCollection\nCollection of blog-objects" as MslsBlogCollection { + -current_blog_id : int + -current_blog_output : bool + -objects : MslsBlog[] + -objects_order : string + -active_plugins : array + -hreflangmap : array + +__construct() + {static} +get_configured_blog_description(blog_id, description) + +get_blogs_of_reference_user(options) + +get_blog(language) + +get_blog_id(language) + +get_current_blog_id() + +is_current_blog(blog) + +has_current_blog() + +get_current_blog() + +get_objects() + +get_object(blog_id) + +is_plugin_active(blog_id) + +get_plugin_active_blogs() + +get() + +get_filtered(filter) + +get_users(fields, number) + {static} +get_blog_language(blog_id, default) + } + class "MslsRequest" as MslsRequest { + {static} +get_config(name) + {static} +has_var(name, input_type) + {static} +get_var(name, input_type) + {static} +get(name, default) + {static} +isset(keys) + {static} +get_request(keys, default) + } + class "MslsOptions\nGeneral options class" as MslsOptions { + #args : array + #name : string + #exists : bool + #sep : string + #autoload : string + -available_languages : array + +with_front : bool + {static} +create(id) + {static} +is_main_page() + {static} +is_tax_page() + {static} +is_query_page() + +__construct() + +get_arg(index, default) + +save(arr) + +delete() + +set(arr) + +get_permalink(language) + +get_postlink(language) + +get_tax_query() + +get_current_link() + +is_excluded() + +is_content_filter() + +get_order() + +get_url(dir) + +get_slug(post_type) + +get_icon(language) + +get_flag_url(language) + +get_available_languages() + {static} +check_for_blog_slug(url, options) + +get_icon_type() + } + class "MslsAdminBar" as MslsAdminBar { + #icon_type : string + #blog_collection : MslsBlogCollection + +__construct(options, blog_collection) + {static} +init() + +update_admin_bar(wp_admin_bar) + +add_node(wp_admin_bar, node_id, title) + #get_title(blog, blavatar) + } + class "MslsJson\nContainer for an array which will used in JavaScript as object in JSON" as MslsJson { + #arr : array + +add(value, label) + {static} +compare(a, b) + +get() + +encode() + +__toString() + } + class "MslsOptionsQueryAuthor\nMslsOptionsQueryAuthor" as MslsOptionsQueryAuthor { + #author_id : int + +__construct(sql_cache) + {static} +get_params() + +has_value(language) + +get_current_link() + } + class "MslsLink\nLink type: Image and text" as MslsLink { + #format_string : string + {static} +get_types() + {static} +get_description() + {static} +get_types_description() + {static} +create(display) + {static} +callback(x) + +__toString() + } + class "MslsMain\nAbstraction for the hook classes" as MslsMain { + #options : MslsOptions + #collection : MslsBlogCollection + +__construct(options, collection) + {static} +init() + +debugger(message) + +get_input_array(object_id) + #get_input_value(key, value) + +is_autosave(post_id) + +verify_nonce() + +delete(object_id) + #save(object_id, class) + } + class "MslsLinkTextOnly\nLink type: Text only" as MslsLinkTextOnly { + #format_string : string + {static} +get_description() + } + class "MslsAdminIconTaxonomy\nHandles backend icons for taxonomies" as MslsAdminIconTaxonomy { + #path : string + +set_href(id) + +set_path() + } + package ContentImport as ContentImport { + class "Relations\nClass Relations" as ContentImport_Relations { + +to_create : MslsOptions[] + #local_options : MslsOptions[] + #import_coordinates : ImportCoordinates + +__construct(import_coordinates) + +merge(relations) + +get_data() + +create() + #create_source_to_local() + #create_local_to_source() + +should_create(creator, dest_lang, dest_post_id) + } + class "ImportCoordinates" as ContentImport_ImportCoordinates { + +source_blog_id : int + +source_post_id : int + +dest_blog_id : int + +dest_post_id : int + +source_post : WP_Post + +source_lang : string + +dest_lang : string + +importers : array + +validate() + +get_importer_for(importer_type) + +parse_importers_from_request() + +set_importer_for(importer_type, slug) + } + class "MetaBox" as ContentImport_MetaBox { + #data : + +render() + #inline_thickbox_url(data) + +print_modal_html() + #inline_thickbox_html(echo, data) + } + class "Service\nClass Service" as ContentImport_Service { + +register() + +hook() + } + class "AttachmentPathFinder" as ContentImport_AttachmentPathFinder { + +filter_srcset(sources, sizeArray, imageSrc, imageMeta, attachmentId) + #has_import_data(attachment_id) + +filter_attachment_url(url, attachment_id) + #get_source_post(attachment_id, msls_imported) + } + class "ImportLogger" as ContentImport_ImportLogger { + #levels_delimiter : + #data : + #import_coordinates : ImportCoordinates + +__construct(import_coordinates) + +merge(logger) + +get_data() + +save() + +log_error(where, what) + #log(where, what, root) + #build_nested_array(path, what) + #build_path(where) + +get_levels_delimiter() + +set_levels_delimiter(levels_delimiter) + +log_success(where, what) + +log_information(key, message) + +get_error(where) + #get_nested_value(where) + +get_success(where) + +get_information(key) + } + class "ContentImporter\nClass ContentImporter" as ContentImport_ContentImporter { + #main : MslsMain + #logger : ImportLogger + #relations : Relations + #handle : bool + #has_created_post : int + +__construct(main) + +get_logger() + +set_logger(logger) + +get_relations() + +set_relations(relations) + +handle_import(data) + #pre_flight_check(data) + +parse_sources() + #get_the_blog_post_ID(blog_id) + #insert_blog_post(blog_id, data) + +handle(handle) + +import_content(import_coordinates, post_fields) + #update_inserted_blog_post_data(blog_id, post_id, data) + #redirect_to_blog_post(dest_blog_id, post_id) + +filter_empty(empty) + } + package LogWriters as ContentImport.LogWriters { + interface "LogWriter" as ContentImport_LogWriters_LogWriter { + +write(data) + } + class "AdminNoticeLogger" as ContentImport_LogWriters_AdminNoticeLogger { + #transient : + #import_coordinates : ImportCoordinates + +write(data) + #get_section_html(section_title, entries, escape_entries) + +show_last_log(echo) + +set_import_coordinates(import_coordinates) + +get_transient() + } + } + package Importers as ContentImport.Importers { + interface "Importer" as ContentImport_Importers_Importer { + +import(data) + +set_import_coordinates(import_coordinates) + +get_logger() + +get_relations() + {static} +info() + } + class "BaseImporter" as ContentImport_Importers_BaseImporter { + +import_coordinates : ImportCoordinates + +logger : ImportLogger + +relations : Relations + +__construct(import_coordinates, logger, relations) + +import(data) + +set_import_coordinates(import_coordinates) + +get_logger() + +get_relations() + {static} +info() + } + class "PostFieldsImporters" as ContentImport_Importers_PostFieldsImporters { + #importers_map : + +details() + } + class "Map" as ContentImport_Importers_Map { + +make(import_coordinates) + +factories() + } + class "TermsImporters" as ContentImport_Importers_TermsImporters { + #importers_map : + +details() + } + class "WithRequestPostAttributes\nTrait WithRequestPostAttributes" as ContentImport_Importers_WithRequestPostAttributes { + #read_post_type_from_request(default) + } + class "PostThumbnailImporters" as ContentImport_Importers_PostThumbnailImporters { + #importers_map : + +details() + } + class "PostMetaImporters" as ContentImport_Importers_PostMetaImporters { + #importers_map : + +details() + } + class "ImportersBaseFactory" as ContentImport_Importers_ImportersBaseFactory { + #importers_map : array + +make(import_coordinates) + +details() + +selected() + #importers_info() + } + class "AttachmentsImporters" as ContentImport_Importers_AttachmentsImporters { + #importers_map : + +details() + } + interface "ImportersFactory" as ContentImport_Importers_ImportersFactory { + +make(import_coordinates) + +details() + +selected() + } + package PostMeta as ContentImport.Importers.PostMeta { + class "Duplicating" as ContentImport_Importers_PostMeta_Duplicating { + {static} +info() + +import(data) + +filter_post_meta(meta) + } + } + package PostThumbnail as ContentImport.Importers.PostThumbnail { + class "Linking\nClass Linking" as ContentImport_Importers_PostThumbnail_Linking { + {static} +info() + +import(data) + #get_attachment_meta(source_post_thumbnail_id) + } + } + package Terms as ContentImport.Importers.Terms { + class "ShallowDuplicating\nClass ShallowDuplicating" as ContentImport_Importers_Terms_ShallowDuplicating { + #reset_taxonomies : array + {static} +info() + +import(data) + #create_local_term(term, msls_term, dest_lang) + #filter_term_meta(meta, term) + #update_object_terms(object_id, dest_term_id, taxonomy) + } + } + package PostFields as ContentImport.Importers.PostFields { + class "Duplicating\nClass Duplicating" as ContentImport_Importers_PostFields_Duplicating { + {static} +info() + +import(data) + +filter_fields() + } + } + package Attachments as ContentImport.Importers.Attachments { + class "Linking\nClass Linking" as ContentImport_Importers_Attachments_Linking { + {static} +info() + +import(data) + } + } + } + } + package Component as Component { + class "Icon\nClass Icon" as Component_Icon { + #map : string[] + +__construct() + #maybe(language, prefix, postfix) + {abstract} #get_include() + {abstract} +get(language) + } + interface "InputInterface\nInterface Input" as Component_InputInterface { + +render() + } + package Input as Component.Input { + class "Group\nClass Options" as Component_Input_Group { + #arr : string[] + #glue : string + +__construct(glue) + +add(input) + +render() + } + class "Label\nClass Label" as Component_Input_Label { + #key : string + #text : string + +__construct(key, text) + +render() + } + class "Option\nClass Option" as Component_Input_Option { + #key : string + #value : string + #selected : string + +__construct(key, value, selected) + +render() + } + class "Select" as Component_Input_Select { + #key : string + #options : Group + +__construct(key, arr, selected) + +render() + } + class "Checkbox\nClass Checkbox" as Component_Input_Checkbox { + #key : string + #selected : string + +__construct(key, value) + +render() + } + class "Text" as Component_Input_Text { + #key : string + #value : string + #size : string + #readonly : string + +__construct(key, value, size, readonly) + +render() + } + } + package Icon as Component.Icon { + class "IconPng\nClass IconPng" as Component_Icon_IconPng { + #get_include() + +get(language) + } + class "IconSvg\nClass IconSvg" as Component_Icon_IconSvg { + #get_include() + +get(language) + } + class "IconLabel\nClass IconLabel" as Component_Icon_IconLabel { + #get_include() + +get(language) + } + } + } + package Map as Map { + class "HrefLang\nClass HrefLang" as Map_HrefLang { + #map : array + +__construct(blogs) + #get_hreflang(language) + +get(language) + } + } + package Query as Query { + class "YearPostsCounterQuery" as Query_YearPostsCounterQuery { + +__invoke(year) + } + class "CleanupOptionsQuery\nCleans up options" as Query_CleanupOptionsQuery { + +__invoke() + } + class "AuthorPostsCounterQuery\nGets the number of published posts by an author" as Query_AuthorPostsCounterQuery { + +__invoke(author_id) + } + class "TranslatedPostIdQuery\nGets the posts_ids of posts that have been translated to a specific language" as Query_TranslatedPostIdQuery { + +__invoke(language) + } + class "MonthPostsCounterQuery\nGets the number of published posts by a month" as Query_MonthPostsCounterQuery { + +__invoke(year, monthnum) + } + class "BlogsInNetworkQuery\nGets the blog_ids of blogs in the network" as Query_BlogsInNetworkQuery { + +__invoke() + } + class "DatePostsCounterQuery\nGets the number of published posts by a date" as Query_DatePostsCounterQuery { + +__invoke(year, monthnum, day) + } + class "AbstractQuery\nAbstractQuery" as Query_AbstractQuery { + #sql_cache : MslsSqlCacher + +__construct(sql_cache) + } + } + Component_Icon <|-- Component_Icon_IconLabel + Component_Icon <|-- Component_Icon_IconPng + Component_Icon <|-- Component_Icon_IconSvg + Component_Icon_IconPng ..> MslsPlugin + Component_Icon_IconSvg ..> MslsPlugin + Component_InputInterface <|-- Component_Input_Checkbox + Component_InputInterface <|-- Component_Input_Group + Component_InputInterface <|-- Component_Input_Label + Component_InputInterface <|-- Component_Input_Option + Component_InputInterface <|-- Component_Input_Select + Component_InputInterface <|-- Component_Input_Text + Component_Input_Group ..> Component_InputInterface + Component_Input_Select ..> Component_Input_Group + Component_Input_Select ..> Component_Input_Option + ContentImport_ContentImporter ..> ContentImport_ImportCoordinates + ContentImport_ContentImporter ..> ContentImport_ImportLogger + ContentImport_ContentImporter ..> ContentImport_Importers_Map + ContentImport_ContentImporter ..> ContentImport_Relations + ContentImport_ContentImporter ..> MslsBlogCollection + ContentImport_ContentImporter ..> MslsMain + ContentImport_ContentImporter ..> MslsOptionsPost + ContentImport_ImportCoordinates ..> MslsBlogCollection + ContentImport_ImportLogger ..> ContentImport_ImportCoordinates + ContentImport_ImportLogger ..> ContentImport_ImportLogger + ContentImport_ImportLogger ..> ContentImport_LogWriters_AdminNoticeLogger + ContentImport_ImportLogger ..> ContentImport_LogWriters_LogWriter + ContentImport_Importers_BaseImporter ..> ContentImport_ImportCoordinates + ContentImport_Importers_BaseImporter ..> ContentImport_ImportLogger + ContentImport_Importers_BaseImporter ..> ContentImport_Relations + ContentImport_Importers_BaseImporter <|-- ContentImport_Importers_Attachments_Linking + ContentImport_Importers_BaseImporter <|-- ContentImport_Importers_PostFields_Duplicating + ContentImport_Importers_BaseImporter <|-- ContentImport_Importers_PostMeta_Duplicating + ContentImport_Importers_BaseImporter <|-- ContentImport_Importers_PostThumbnail_Linking + ContentImport_Importers_BaseImporter <|-- ContentImport_Importers_Terms_ShallowDuplicating + ContentImport_Importers_Importer ..> ContentImport_ImportCoordinates + ContentImport_Importers_Importer ..> ContentImport_ImportLogger + ContentImport_Importers_Importer ..> ContentImport_Relations + ContentImport_Importers_Importer <|-- ContentImport_Importers_BaseImporter + ContentImport_Importers_ImportersBaseFactory ..> ContentImport_ImportCoordinates + ContentImport_Importers_ImportersBaseFactory ..> ContentImport_Importers_BaseImporter + ContentImport_Importers_ImportersBaseFactory ..> ContentImport_Importers_Importer + ContentImport_Importers_ImportersBaseFactory <|-- ContentImport_Importers_AttachmentsImporters + ContentImport_Importers_ImportersBaseFactory <|-- ContentImport_Importers_PostFieldsImporters + ContentImport_Importers_ImportersBaseFactory <|-- ContentImport_Importers_PostMetaImporters + ContentImport_Importers_ImportersBaseFactory <|-- ContentImport_Importers_PostThumbnailImporters + ContentImport_Importers_ImportersBaseFactory <|-- ContentImport_Importers_TermsImporters + ContentImport_Importers_ImportersFactory ..> ContentImport_ImportCoordinates + ContentImport_Importers_ImportersFactory ..> ContentImport_Importers_Importer + ContentImport_Importers_ImportersFactory <|-- ContentImport_Importers_ImportersBaseFactory + ContentImport_Importers_Map ..> ContentImport_ImportCoordinates + ContentImport_Importers_Map ..> ContentImport_Importers_AttachmentsImporters + ContentImport_Importers_Map ..> ContentImport_Importers_PostFieldsImporters + ContentImport_Importers_Map ..> ContentImport_Importers_PostMetaImporters + ContentImport_Importers_Map ..> ContentImport_Importers_PostThumbnailImporters + ContentImport_Importers_Map ..> ContentImport_Importers_TermsImporters + ContentImport_Importers_PostThumbnail_Linking ..> ContentImport_AttachmentPathFinder + ContentImport_Importers_Terms_ShallowDuplicating ..> MslsOptionsTax + ContentImport_Importers_Terms_ShallowDuplicating ..> MslsOptionsTaxTerm + ContentImport_LogWriters_AdminNoticeLogger ..> ContentImport_ImportCoordinates + ContentImport_LogWriters_LogWriter <|-- ContentImport_LogWriters_AdminNoticeLogger + ContentImport_MetaBox ..> ContentImport_Importers_Map + ContentImport_MetaBox ..> MslsBlogCollection + ContentImport_MetaBox ..> MslsFields + ContentImport_MetaBox ..> MslsOptionsPost + ContentImport_MetaBox ..> MslsPlugin + ContentImport_MetaBox ..> MslsRequest + ContentImport_Relations "1" ..> "*" MslsOptions + ContentImport_Relations ..> ContentImport_ImportCoordinates + ContentImport_Relations ..> ContentImport_Relations + ContentImport_Relations ..> MslsOptions + ContentImport_Service ..> ContentImport_AttachmentPathFinder + ContentImport_Service ..> ContentImport_ContentImporter + ContentImport_Service ..> ContentImport_LogWriters_AdminNoticeLogger + Map_HrefLang ..> MslsBlogCollection + MslsAdmin ..> Component_Input_Checkbox + MslsAdmin ..> Component_Input_Group + MslsAdmin ..> Component_Input_Label + MslsAdmin ..> Component_Input_Select + MslsAdmin ..> Component_Input_Text + MslsAdmin ..> MslsAdmin + MslsAdmin ..> MslsLink + MslsAdmin ..> MslsPlugin + MslsAdmin ..> MslsRegistry + MslsAdminBar ..> MslsAdminBar + MslsAdminBar ..> MslsBlog + MslsAdminBar ..> MslsBlogCollection + MslsAdminBar ..> MslsOptions + MslsAdminIcon ..> Component_Icon_IconLabel + MslsAdminIcon ..> Component_Icon_IconSvg + MslsAdminIcon ..> MslsAdminIcon + MslsAdminIcon ..> MslsAdminIconTaxonomy + MslsAdminIcon ..> MslsContentTypes + MslsAdminIcon <|-- MslsAdminIconTaxonomy + MslsAdminIconTaxonomy ..> MslsAdminIcon + MslsAdminIconTaxonomy ..> MslsAdminIconTaxonomy + MslsAdminIconTaxonomy ..> MslsTaxonomy + MslsBlock ..> MslsOptions + MslsBlock ..> MslsPlugin + MslsBlog ..> MslsAdminIcon + MslsBlog ..> MslsBlog + MslsBlog ..> MslsBlogCollection + MslsBlog ..> MslsOptions + MslsBlogCollection "1" ..> "*" MslsBlog + MslsBlogCollection ..> MslsBlog + MslsBlogCollection ..> MslsOptions + MslsBlogCollection ..> MslsPlugin + MslsContentFilter ..> MslsOptions + MslsContentFilter ..> MslsOutput + MslsContentTypes ..> MslsContentTypes + MslsContentTypes ..> MslsPostType + MslsContentTypes ..> MslsRequest + MslsContentTypes ..> MslsTaxonomy + MslsContentTypes <|-- MslsPostType + MslsContentTypes <|-- MslsTaxonomy + MslsCustomColumn ..> MslsAdminIcon + MslsCustomColumn ..> MslsBlogCollection + MslsCustomColumn ..> MslsCustomColumn + MslsCustomColumn ..> MslsOptions + MslsCustomColumn ..> MslsPostType + MslsCustomColumn <|-- MslsCustomColumnTaxonomy + MslsCustomColumnTaxonomy ..> MslsCustomColumnTaxonomy + MslsCustomColumnTaxonomy ..> MslsOptionsTax + MslsCustomColumnTaxonomy ..> MslsTaxonomy + MslsCustomFilter ..> Component_Input_Select + MslsCustomFilter ..> MslsCustomFilter + MslsCustomFilter ..> MslsFields + MslsCustomFilter ..> MslsPostType + MslsCustomFilter ..> MslsRequest + MslsCustomFilter ..> MslsSqlCacher + MslsCustomFilter ..> Query_TranslatedPostIdQuery + MslsGetSet ..> MslsGetSet + MslsGetSet <|-- MslsLink + MslsGetSet <|-- MslsOptions + MslsJson ..> MslsJson + MslsLanguageArray ..> MslsLanguageArray + MslsLink ..> MslsLink + MslsLink ..> MslsLinkImageOnly + MslsLink ..> MslsLinkTextImage + MslsLink ..> MslsLinkTextOnly + MslsLink <|-- MslsLinkImageOnly + MslsLink <|-- MslsLinkTextImage + MslsLink <|-- MslsLinkTextOnly + MslsMain ..> MslsBlogCollection + MslsMain ..> MslsFields + MslsMain ..> MslsLanguageArray + MslsMain ..> MslsOptions + MslsMain ..> MslsOptionsPost + MslsMain ..> MslsPlugin + MslsMain ..> MslsRequest + MslsMain <|-- MslsAdmin + MslsMain <|-- MslsCustomColumn + MslsMain <|-- MslsCustomFilter + MslsMain <|-- MslsMetaBox + MslsMain <|-- MslsOutput + MslsMain <|-- MslsPostTag + MslsMetaBox ..> ContentImport_MetaBox + MslsMetaBox ..> MslsAdminIcon + MslsMetaBox ..> MslsFields + MslsMetaBox ..> MslsJson + MslsMetaBox ..> MslsMetaBox + MslsMetaBox ..> MslsOptionsPost + MslsMetaBox ..> MslsPlugin + MslsMetaBox ..> MslsPostType + MslsMetaBox ..> MslsRequest + MslsOptions ..> Component_Icon_IconPng + MslsOptions ..> MslsAdminIcon + MslsOptions ..> MslsContentTypes + MslsOptions ..> MslsOptions + MslsOptions ..> MslsOptionsPost + MslsOptions ..> MslsOptionsQuery + MslsOptions ..> MslsOptionsTax + MslsOptions ..> MslsPlugin + MslsOptions <|-- MslsOptionsPost + MslsOptions <|-- MslsOptionsQuery + MslsOptions <|-- MslsOptionsTax + MslsOptionsQuery ..> MslsOptionsQuery + MslsOptionsQuery ..> MslsOptionsQueryAuthor + MslsOptionsQuery ..> MslsOptionsQueryDay + MslsOptionsQuery ..> MslsOptionsQueryMonth + MslsOptionsQuery ..> MslsOptionsQueryPostType + MslsOptionsQuery ..> MslsOptionsQueryYear + MslsOptionsQuery ..> MslsSqlCacher + MslsOptionsQuery <|-- MslsOptionsQueryAuthor + MslsOptionsQuery <|-- MslsOptionsQueryDay + MslsOptionsQuery <|-- MslsOptionsQueryMonth + MslsOptionsQuery <|-- MslsOptionsQueryPostType + MslsOptionsQuery <|-- MslsOptionsQueryYear + MslsOptionsQueryAuthor ..> MslsSqlCacher + MslsOptionsQueryAuthor ..> Query_AuthorPostsCounterQuery + MslsOptionsQueryDay ..> MslsSqlCacher + MslsOptionsQueryDay ..> Query_DatePostsCounterQuery + MslsOptionsQueryMonth ..> MslsSqlCacher + MslsOptionsQueryMonth ..> Query_MonthPostsCounterQuery + MslsOptionsQueryPostType ..> MslsSqlCacher + MslsOptionsQueryYear ..> MslsSqlCacher + MslsOptionsQueryYear ..> Query_YearPostsCounterQuery + MslsOptionsTax ..> MslsContentTypes + MslsOptionsTax ..> MslsOptionsTax + MslsOptionsTax ..> MslsOptionsTaxTerm + MslsOptionsTax ..> MslsOptionsTaxTermCategory + MslsOptionsTax <|-- MslsOptionsTaxTerm + MslsOptionsTaxTerm <|-- MslsOptionsTaxTermCategory + MslsOutput ..> Map_HrefLang + MslsOutput ..> MslsLink + MslsOutput ..> MslsOptions + MslsOutput ..> MslsOutput + MslsPlugin ..> ContentImport_Service + MslsPlugin ..> MslsAdmin + MslsPlugin ..> MslsAdminBar + MslsPlugin ..> MslsBlock + MslsPlugin ..> MslsContentFilter + MslsPlugin ..> MslsCustomColumn + MslsPlugin ..> MslsCustomColumnTaxonomy + MslsPlugin ..> MslsCustomFilter + MslsPlugin ..> MslsFields + MslsPlugin ..> MslsMetaBox + MslsPlugin ..> MslsOptions + MslsPlugin ..> MslsOutput + MslsPlugin ..> MslsPlugin + MslsPlugin ..> MslsPostTag + MslsPlugin ..> MslsRequest + MslsPlugin ..> MslsShortCode + MslsPlugin ..> MslsSqlCacher + MslsPlugin ..> MslsWidget + MslsPlugin ..> Query_BlogsInNetworkQuery + MslsPlugin ..> Query_CleanupOptionsQuery + MslsPostTag ..> MslsAdminIcon + MslsPostTag ..> MslsContentTypes + MslsPostTag ..> MslsFields + MslsPostTag ..> MslsJson + MslsPostTag ..> MslsOptionsTax + MslsPostTag ..> MslsPostTag + MslsPostTag ..> MslsPostTagClassic + MslsPostTag ..> MslsRequest + MslsPostTag <|-- MslsPostTagClassic + MslsPostTagClassic ..> MslsAdminIcon + MslsPostTagClassic ..> MslsBlog + MslsPostTagClassic ..> MslsContentTypes + MslsPostTagClassic ..> MslsOptionsTax + MslsPostType ..> MslsRequest + MslsRegistry ..> MslsRegistry + MslsRegistryInstance ..> MslsRegistry + MslsRegistryInstance <|-- ContentImport_AttachmentPathFinder + MslsRegistryInstance <|-- ContentImport_ContentImporter + MslsRegistryInstance <|-- ContentImport_Importers_ImportersBaseFactory + MslsRegistryInstance <|-- ContentImport_Importers_Map + MslsRegistryInstance <|-- ContentImport_LogWriters_AdminNoticeLogger + MslsRegistryInstance <|-- ContentImport_MetaBox + MslsRegistryInstance <|-- ContentImport_Service + MslsRegistryInstance <|-- MslsBlogCollection + MslsRegistryInstance <|-- MslsContentTypes + MslsRegistryInstance <|-- MslsGetSet + MslsRequest ..> MslsFields + MslsShortCode ..> MslsOptions + MslsShortCode ..> MslsWidget + MslsTaxonomy ..> MslsRequest + MslsWidget ..> MslsOutput + Query_AbstractQuery ..> MslsSqlCacher + Query_AbstractQuery <|-- Query_AuthorPostsCounterQuery + Query_AbstractQuery <|-- Query_BlogsInNetworkQuery + Query_AbstractQuery <|-- Query_CleanupOptionsQuery + Query_AbstractQuery <|-- Query_DatePostsCounterQuery + Query_AbstractQuery <|-- Query_MonthPostsCounterQuery + Query_AbstractQuery <|-- Query_TranslatedPostIdQuery + Query_AbstractQuery <|-- Query_YearPostsCounterQuery +@enduml