PromptEntryBase.h

/**************************************************************************
*   Copyright (c) 2008, 2022-2024 Cisco Systems, Inc.
*   All Rights Reserved. Cisco Highly Confidential.
***************************************************************************
*
*   File:   PromptEntryBase.h
*   Date:   01/2008
*
***************************************************************************
*   Prompt Entry base class implementation for the Client API.
***************************************************************************/
 
#ifndef _PROMPTENTRYBASE_
#define _PROMPTENTRYBASE_
 
 
#include "api.h"
#include <list>
#include <unordered_set>
 
 
#define PROMPT_ENTRY_VALUE_TRUE  _T("true")
#define PROMPT_ENTRY_VALUE_FALSE  _T("false")
 
class VPN_VPNAPI PromptEntryBase
{
public:
 
    bool setValue(const tstring& value);
    bool clearValue();
 
    const tstring &getPromptName() const;
 
    const tstring &getPromptLabel() const;
 
    bool isEnabled() const;
 
    void setEnabled(bool bIsEnabled);
 
    bool isVisible() const;
 
    void setVisible(bool bIsVisible);
 
    // if this is a PromptEntry that has a list of values
    // (e.g. combo box style) the default will be to mark it as a group
    // combo.  This method allows the group designation to be set directly.
    //
    void setEntryGroup(bool bIsEntryGroup);
 
 
    PromptEntryBase(tstring PromptName,
                    tstring PromptLabel,
                    PromptType promptType = Prompt_Input,
                    const tstring& DefaultValue = EmptyString,
                    ApiStringMap LabelValues = EmptyLabelValues);
 
 
    void setPromptLabel(tstring label);
 
    // In cases of prompt types with options (checkbox, combobox),
    // this will return the translated label (of the option).
    const tstring &getValue() const;
 
    // this function returns the internal representation of the value
    const tstring &getTrueValue() const;
 
    const std::list<tstring> &getValueOptions() const;
 
    bool isEntryGroup() const;
 
    bool isReadOnly() const;
 
    PromptType getPromptType() const;
 
    size_t GetGroupAttributesCount();
 
 
    virtual ~PromptEntryBase();
 
    static const tstring EmptyString;
 
    static const std::list<tstring> EmptyList;
 
    static const ApiStringMap EmptyLabelValues;
 
    // Deep Copy Assignment Operator
    //
    PromptEntryBase& operator=(const PromptEntryBase& existingEntry)
    {
        return deepCopy(existingEntry);
    }
 
    // Deep Copy Constructor
    //
    explicit PromptEntryBase(const PromptEntryBase& existingEntry)
    {
        deepCopy(existingEntry);
    }
 
 
private:
 
    PromptEntryBase& deepCopy(const PromptEntryBase& existingEntry);
 
    tstring ms_PromptName;
    tstring ms_PromptLabel;
    PromptType me_PromptType;
    tstring ms_Value;
    ApiStringMap msm_LabelValueMap;
    std::list<tstring> mls_ValueOptions;
    bool mb_IsEntryGroup;
    bool mb_Enabled;
    bool mb_Visible;
 
public:
 
    class GroupAttributes
    {
    public:
        GroupAttributes() :
            CredRequired(true),
            UsesSDIAuth(false),
            UsernameEditable(true),
            SecondaryUsernameEditable(true),
            UsesSecondaryAuth(false)
        {
        }
 
        // Deep Copy Constructor
        //
        explicit GroupAttributes(
            const GroupAttributes& existingGroupAttr)
        {
            deepCopy(existingGroupAttr);
        }
 
        // Deep Copy Assignment Operator
        //
        GroupAttributes& operator=(
            const GroupAttributes& existingGroupAttr)
        {
            return deepCopy(existingGroupAttr);
        }
 
        bool CredRequired;
        bool UsesSDIAuth;
        bool UsernameEditable;
        tstring Username;
        bool SecondaryUsernameEditable;
        tstring SecondaryUsername;
        bool UsesSecondaryAuth;
 
    private:
        GroupAttributes& deepCopy(const GroupAttributes& existingGroupAttr)
        {
            if (std::addressof(existingGroupAttr) != this)
            {
                CredRequired = existingGroupAttr.CredRequired;
                UsesSDIAuth = existingGroupAttr.UsesSDIAuth;
                UsernameEditable = existingGroupAttr.UsernameEditable;
                Username = existingGroupAttr.Username.c_str();
                SecondaryUsernameEditable = existingGroupAttr.SecondaryUsernameEditable;
                SecondaryUsername = existingGroupAttr.SecondaryUsername.c_str();
                UsesSecondaryAuth = existingGroupAttr.UsesSecondaryAuth;
            }
            return *this;
        }
    };
 
    class SingleAttributes
    {
    public:
        SingleAttributes() :
            SecondaryAuthEntry(false),
            SSOTimeoutSeconds(0),
            SSOIsExternalBrowser(false)
        {
        }
 
        // Deep Copy Constructor
        //
        explicit SingleAttributes(
            const SingleAttributes& existingSingleAttr)
        {
            deepCopy(existingSingleAttr);
        }
 
        // Deep Copy Assignment Operator
        //
        SingleAttributes& operator=(
            const SingleAttributes& existingSingleAttr)
        {
            return deepCopy(existingSingleAttr);
        }
 
        bool SecondaryAuthEntry;
        tstring SSOURL;
        tstring SSOFinalURL;
        tstring SSOTokenCookieName;
        tstring SSOErrorCookieName;
        unsigned int SSOTimeoutSeconds;
        tstring SSOUserAgent;
        bool SSOIsExternalBrowser;
        std::unordered_set<tstring> SSOClientCertReqIgnoredFqdns;
 
    private:
        SingleAttributes& deepCopy(const SingleAttributes& existingSingleAttr)
        {
            if (std::addressof(existingSingleAttr) != this)
            {
                SecondaryAuthEntry = existingSingleAttr.SecondaryAuthEntry;
                SSOURL = existingSingleAttr.SSOURL.c_str();
                SSOFinalURL = existingSingleAttr.SSOFinalURL.c_str();
                SSOTokenCookieName = existingSingleAttr.SSOTokenCookieName.c_str();
                SSOErrorCookieName = existingSingleAttr.SSOErrorCookieName.c_str();
                SSOTimeoutSeconds = existingSingleAttr.SSOTimeoutSeconds;
                SSOUserAgent = existingSingleAttr.SSOUserAgent.c_str();
                SSOIsExternalBrowser = existingSingleAttr.SSOIsExternalBrowser;
                for (const auto& fqdn : existingSingleAttr.SSOClientCertReqIgnoredFqdns)
                {
                    SSOClientCertReqIgnoredFqdns.insert(fqdn.c_str());
                }
            }
            return *this;
        }
    };
 
    typedef std::map<tstring, GroupAttributes> GroupAttributesMap;
 
    const GroupAttributes& getGroupAttributes(const tstring& group) const;
    void setGroupAttributesMap(const GroupAttributesMap& groupAttributesMap);
 
    const SingleAttributes& getSingleAttributes() const;
    void setSingleAttributes(const SingleAttributes& singleAttributes);
 
private:
 
    void copyGroupAttributesMap (const GroupAttributesMap &srcMap,
                                 GroupAttributesMap &dstMap);
 
    static const GroupAttributes DefaultGroupAttributes;
    GroupAttributesMap m_GroupAttributesMap;
    SingleAttributes m_SingleAttributes;
};
 
 
#endif // _PROMPTENTRYBASE_