Domains.idl

Go to the documentation of this file.

/**
 * @file   Domains.idl
 * @brief  %Domains settings
 *
 * @author Dusan Juhas
 *
 * @copyright Copyright © 2017 Kerio Technologies s.r.o.
 */

#import <kerio/web/idl/SharedStructures.idl>
#import <AdminStructures.idl>
#import <DistributedDomain.idl>

module kerio {
module jsonapi {
module admin {

/**
 * Delivery Type
 */
enum DeliveryType {
   Online,           ///< deliver online, immediatelly
   OfflineScheduler, ///< delivery is started by scheduler
   OfflineEtrn       ///< delivery is started by ETRN command from remote host
};

/**
 * Forwarding action
 * Note: all fields must be assigned if used in set methods
 */
struct Forwarding {
   boolean  isEnabled;     ///< is forwarding enabled?
   string   host;       ///< hostname or IP address to forward
   long  port;       ///< host port
   DeliveryType how;    ///< how to deliver
   boolean preventLoop; ///< do not deliver to domain alias (applicable when Domain.aliasList is not empty)
};

enum DirectoryServiceType {
   WindowsActiveDirectory,    ///< Windows Active Directory
   AppleDirectoryKerberos, ///< Apple Open Directory with Kerberos authentication
   AppleDirectoryPassword, ///< Apple Open Directory with Password Server authentication
   KerioDirectory,          ///< Kerio Directory (reserved for future use)
   CustomLDAP               ///< Custom Generic LDAP
};

/**
 *
 * Note: all fields must be assigned if used in set methods (except password)
 */
struct DirectoryAuthentication {
   string   username;
   string   password;
   boolean  isSecure;      ///< is used LDAPS?
};

/**
 * Directory service configuration
 */
struct DirectoryServiceConfiguration {
   DirectoryServiceType serviceType;   ///< type of the service
   DirectoryAuthentication authentication;   ///< authentication information
   string               directoryName; ///< Active Directory only: Directory name
   string               ldapSuffix;    ///< Apple Directory, Kerio Directory: LDAP Search Suffix
};

/**
 * Directory service information
 */
struct DirectoryService {
   boolean              isEnabled;     ///< directory service is in use / isEnabled must be always assigned if used in set methods
   DirectoryServiceType serviceType;   ///< type of the service
   string               customMapFile; ///< Custom Generic LDAP only: custom map filename
   DirectoryAuthentication authentication;   ///< authentication information
   string               hostname;      ///< directory service hostname
   string               backupHostname;   ///< directory service backup hostname
   string               directoryName; ///< Active Directory only: Directory name
   string               ldapSuffix;    ///< Apple Directory, Kerio Directory: LDAP Search Suffix
};

/**
 *
 * Note: all fields must be assigned if used in set methods
 */
struct Footer {
   boolean isUsed;         ///< is footer used
   string   text;       ///< text that will be appended to every message sent from this domain
   boolean isHtml;         ///< if is value false the text is precessed as plaintext
   boolean isUsedInDomain; ///< footer is used also for e-mails within domain
};

/**
 *
 * Note: all fields must be assigned if used in set methods
 */
struct WebmailLogo {
   boolean isUsed;   ///< has domain user defined logo?
   string  url;   ///< user defined logo URL
};

struct DomainRenameInfo {
   boolean isRenamed;
   string oldName;
   string newName;
};

struct DomainQuota {
   kerio::web::SizeLimit diskSizeLimit;             ///< max. disk usage
   kerio::web::ByteValueWithUnits consumedSize;     ///< [READ-ONLY] current disk usage
   QuotaNotification notification;                  ///< option for notification
   long warningLimit;                               ///< limit in per cent
   string email;                                    ///< if quota is exceeded the notification will be sent to this address
   boolean blocks;                                  ///< if reaching the quota will block creation of a new items
};

/**
 * Domain details
 */
struct Domain {
   kerio::web::KId         id;                  ///< [READ-ONLY] global identification of domain
   string               name;             ///< [REQUIRED FOR CREATE] [WRITE-ONCE] name
   string               description;         ///< description
   boolean              isPrimary;           ///< is this domain primary?
   long              userMaxCount;        ///< maximum users per domain, 'unlimited' constant can be used
   boolean passwordExpirationEnabled;           ///< is password expiration enabled for this domain?
   long passwordExpirationDays;              ///< password expiration interval
   long passwordHistoryCount;                ///< lenght of password history
   boolean passwordComplexityEnabled;           ///< is password complexity enabled for this domain?
   long passwordMinimumLength;                  ///< minimum password length for complexity feature
   kerio::web::SizeLimit   outgoingMessageLimit;   ///< outgoing message size limit
   ActionAfterDays         deletedItems;        ///< clean Deleted Items folder (AC maximum: 24855)
   ActionAfterDays         junkEmail;           ///< clean Junk Email folder (AC maximum: 24855)
   ActionAfterDays         sentItems;           ///< clean Sent Items folder (AC maximum: 24855)
   ActionAfterDays         autoDelete;          ///< clean all folders (AC minimun:30, maximum: 24855)
   ActionAfterDays         keepForRecovery;     ///< keep deleted messages for recovery
   kerio::web::StringList  aliasList;           ///< list of domain alternative names
   Forwarding           forwardingOptions;      ///< forwarding settings
   DirectoryService     service;          ///< directory service configuration
   Footer               domainFooter;        ///< domain footer setting
   string               kerberosRealm;       ///< Kerberos Realm name
   string               winNtName;           ///< Windows NT domain name - available on windows only
   string               pamRealm;            ///< PAM Realm name - available on linux only
   kerio::web::OptionalString ipAddressBind;    ///< specific IP address bind
   WebmailLogo          logo;             ///< user defined logo
   CustomImage             customClientLogo;    ///< Use custom logo in Kerio Connect Client (if not enabled global option from AdvancedOptionsSetting.webMail is used)
   boolean              checkSpoofedSender;     ///<  
   DomainRenameInfo     renameInfo;          ///< [READ-ONLY] if domain was renamed, contain old and new domain name
   DomainQuota          domainQuota;         ///< domain's quota settings
   boolean              isDistributed;       ///< [READ-ONLY] if domain is distributed
   boolean              isDkimEnabled;       ///< true if DKIM is used for this domain
   boolean              isLdapManagementAllowed; ///< [READ-ONLY] true if directory service user/group can be created/deleted
   boolean              isInstantMessagingEnabled; ///< true if Instant Messaging is enabled for this domain
   boolean                 useRemoteArchiveAddress; ///< if true emails are archived to remoteArchiveAddress
   string                  remoteArchiveAddress;    ///< remote archiving address
   boolean                 archiveLocalMessages;    ///< if true emails from emails are archived to remoteArchiveAddress
   boolean                 archiveIncomingMessages; ///< if true emails are archived to remoteArchiveAddress
   boolean                 archiveOutgoingMessages; ///< if true emails are archived to remoteArchiveAddress
   boolean              archiveBeforeFilter;       ///< if true emails are archived before content filter check
};

/**
 * Identical settings for all domains
 */
struct DomainSetting {
   string   hostname;            ///< internet hostname - how this machine introduces itself in SMTP,POP3...
   boolean  publicFoldersPerDomain; ///< true=public folders are unique per each domain / false=global for all domains
   kerio::web::KId serverId;     ///< id of server primary used in cluster
};

/**
 * List of domains
 */
typedef sequence<Domain> DomainList;

/**
 * Types of user amount limit
 */
enum UserLimitType {
   DomainLimit,   ///< stricter limit for amount of users is on domain
   LicenseLimit   ///< stricter limit for amount of users is on license
};

/**
 * User limit information
 */
struct MaximumUsers {
   boolean        isUnlimited;      ///< is it a special case with no limit for users ?
   long        allowedUsers;     ///< number of allowed users (take minimum of server and domain limit)
   long            limit;           ///< max. user limit
   UserLimitType  limitType;        ///< max. user limit type, if domain limit == license limit -> use license
};

/**
 * User count information
 */
struct UserDomainCountInfo {
   long           currentUsers;     ///< number of created users on domain
   MaximumUsers      allowedUsers;     ///< number of allowed users, take stricter limit from max. number for domain, max. number by license
};

/**
 * Domain management
 */
interface Domains {

   /**
    * Check integrity of all public folders.
    * If corrupted folder is found, try to fix it.
    */
   void checkPublicFoldersIntegrity();

   /**
    * Create new domains.
    *
    * @param errors - error message list
    * @param result - particular results for all items
    * @param domains - new domain entities
    */
   void create(out kerio::web::ErrorList errors, out kerio::web::CreateResultList result, in DomainList domains);

   /**
    * Generate password which meets current password policy of a given domain.
    *
    * @param password - generated password
    * @param domainId - ID of the domain
    */
   void generatePassword(out string password, in kerio::web::KId domainId);

   /**
    * Obtain a list of domains.
    *
    * @param list - domains
    * @param totalItems - amount of domains for given search condition, useful when limit is defined in kerio::web::SearchQuery
    * @param query - query conditions and limits
    */
   void get(out DomainList list, out long totalItems, in kerio::web::SearchQuery query);

   /**
    * DKIM requires public key in DNS for domain.
    * Returns DNS TXT record to be added into DNS.
    */
   void getDkimDnsRecord(out string detail, in string domain);

   /**
    * Get settings common in all domains.
    *
    * @param setting - domain global setting
    */
   void getSettings(out DomainSetting setting);

   /**
    * Get information about user count and limit for domain. Disabled users are not counted.
    *
    * @param countInfo - structure with users count and limit
    * @param domainId - ID of the domain which will be renamed
    */
   void getUserCountInfo(out UserDomainCountInfo countInfo, in kerio::web::KId domainId);

   /**
    * Remove domains.
    *
    * @param errors - error message list
    * @param domainIds - list of global identifiers of domains to be deleted
    */
   void remove(out kerio::web::ErrorList errors, in kerio::web::KIdList domainIds);

   /**
    * Start domain renaming process.
    *
    * @param error - error message
    * @param domainId - ID of the domain which will be renamed
    * @param newName - new domain name
    */
   void rename(out ClusterError error, in kerio::web::KId domainId, in string newName);

   /**
    * Save a new footer's image.
    *
    * @param imgUrl - url to saved image
    * @param fileId - id of uploaded file
    */
   void saveFooterImage(out string imgUrl, in string fileId);

   /**
    * Save a new logo.
    *
    * @param logoUrl - path to the saved file
    * @param fileId - ID of the uploaded file
    * @param domainId - global domain identifier
    */
   void saveWebMailLogo(out string logoUrl, in string fileId, in kerio::web::KId domainId);

   /**
    * Set existing domains to given pattern.
    *
    * @param errors - error message list
    * @param domainIds - list of the domain's global identifier(s)
    * @param pattern - pattern to use for new values
    */
   void set(out kerio::web::ErrorList errors, in kerio::web::KIdList domainIds, in Domain pattern);

   /**
    * Set settings for all domains.
    *
    * @param setting - domain global settings
    */
   void setSettings(in DomainSetting setting);

   /**
    * Test connection between Kerio Connect and domain controller.
    *
    * @param errors - error message
    * @param hostnames - directory server (primary and secondary if any)
    * @param config - directory service configuration. If password is empty then it is taken from domain by 'domainId'.
    * @param domainId - global domain identifier
    */
   void testDomainController(out kerio::web::ErrorList errors, in kerio::web::StringList hostnames, in DirectoryServiceConfiguration config, in kerio::web::KId domainId);

   /**
    * Tests DKIM DNS TXT status for domain list.
    *     
    * @param errors - error message
    * @param hostnames - hostnames checked for DKIM public key in DNS
    */
   void testDkimDnsStatus(out kerio::web::ErrorList errors, in kerio::web::StringList hostnames);

   /**
   * Return all supported placeholders for domain footer
   */
   void getDomainFooterPlaceholders(out NamedConstantList placeholders);
};

}; }; };//end of namespace