ContactInfo.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/Model.h>
#if NDEVR_CONTACT_INFO
#include <NDEVR/Translator.h>
namespace NDEVR
{
    class ContactName : public Model
    {
    public:
        ContactName(const Model& model)
            : Model(model)
        {
 
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                setModelProperty(Model::e_type, TypeName());
            }
        }
        void set(const String& name)
        {
            setProperty(DesignObject::e_untranslated_string_data, name);
        }
        String get() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
        static constexpr const char* ValidRegex() { return "(\\w+)(\\.|_)?(\\w*)@(\\w+)(\\.(\\w+))+"; }
        static constexpr const char* TypeName() { return "contact_name"; }
    };
    class TelephoneNumber : public Model
    {
    public:
        TelephoneNumber(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                setModelProperty(Model::e_type, TypeName());
                setProperty(Model::e_name, _t("Mobile"));
                setProperty(Model::e_icon, "mobile");
            }
        }
        String phoneNumber() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
        void updatePhoneNumber(const String& phone_number, const void* lock_ptr = nullptr)
        {
            updateProperty<String>(DesignObject::e_untranslated_string_data, phone_number, lock_ptr);
        }
        String phoneNumberName() const
        {
            return getProperty<String>(DesignObject::e_name);
        }
        void updatePhoneNumberName(const String& phone_number_name, const void* lock_ptr = nullptr)
        {
            updateProperty<String>(DesignObject::e_name, phone_number_name, lock_ptr);
        }
        static constexpr const char* ValidRegex() { return "sad";/*TODO*/ }
        static constexpr const char* TypeName() { return "telephone_number"; }
        
    };
    
    class PhysicalAddressModel : public Model
    {
    public:
        PhysicalAddressModel(const Model& model)
            : Model(model)
        {
            if (getModelProperty<String>(Model::e_type) != TypeName())
            {
                setModelProperty(Model::e_type, TypeName());
                setAddress("\t\t\t");
                setProperty(Model::e_name, _t("Address"));
                setProperty(Model::e_icon, "pin");
            }
        }
        String address() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
        void setAddress(const String& address)
        {
            lib_assert(address.count('\t') == 3, "Bad Address");
            if (address.count('\t') == 3)
                updateProperty(DesignObject::e_untranslated_string_data, address);
        }
        String streetAddress() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data).splitString('\t')[0];
        }
        void setStreetAddress(const String& street)
        {
            String current_data = getProperty<String>(DesignObject::e_untranslated_string_data);
            Buffer<String> parts = current_data.splitString('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 0)
                    current_data += street;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }
        String city() const
        {
            String s = getProperty<String>(DesignObject::e_untranslated_string_data);
            if (s.contains('\t'))
                return s.splitString('\t')[1];
            else
                return String();
        }
        void setCity(const String& city)
        {
            String current_data = getProperty<String>(DesignObject::e_untranslated_string_data);
            Buffer<String> parts = current_data.splitString('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 1)
                    current_data += city;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }
 
        String state() const
        {
            String s = getProperty<String>(DesignObject::e_untranslated_string_data);
            if (s.count('\t') >= 2)
                return s.splitString('\t')[2];
            else
                return String();
        }
        void setState(const String& state)
        {
            String current_data = getProperty<String>(DesignObject::e_untranslated_string_data);
            Buffer<String> parts = current_data.splitString('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 2)
                    current_data += state;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }
 
        String zipCode() const
        {
            String s = getProperty<String>(DesignObject::e_untranslated_string_data);
            if (s.count('\t') >= 3)
                return s.splitString('\t')[3];
            else
                return String();
        }
        void setZipCode(const String& zip)
        {
            String current_data = getProperty<String>(DesignObject::e_untranslated_string_data);
            Buffer<String> parts = current_data.splitString('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 3)
                    current_data += zip;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }
        static constexpr const char* TypeName() { return "physical_address"; }
    };
    class EmailAddress : public Model
    {
    public:
        EmailAddress(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                setModelProperty(Model::e_type, TypeName());
            }
        }
        static constexpr const char* TypeName() { return "email_address"; }
        void set(const String& email)
        {
            setProperty(DesignObject::e_untranslated_string_data, email);
        }
        String get() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
    };
    class CompanyName : public Model
    {
    public:
        CompanyName(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                setModelProperty(Model::e_type, TypeName());
            }
        }
        void set(const String& companyName)
        {
            setProperty(DesignObject::e_untranslated_string_data, companyName);
        }
        String get() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
        static constexpr const char* TypeName() { return "company_name"; }
    };
    class CompanyRole : public Model
    {
    public:
        CompanyRole(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                setModelProperty(Model::e_type, TypeName());
            }
        }
        void set(const String& role)
        {
            setProperty(DesignObject::e_untranslated_string_data, role);
        }
        String get() const
        {
            return getProperty<String>(DesignObject::e_untranslated_string_data);
        }
        static constexpr const char* TypeName() { return "company_role"; }
    };
 
    class ContactInfo : public Model
    {
    public:
        ContactInfo(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                //setup model for first time
                createChildren(5);
                setModelProperty(Model::e_type, TypeName());
                setProperty(DesignObject::e_name, _t("Contact"));
            }
        }
        ContactName contactName()
        {
            return ContactName(getChild(0));
        }
        TelephoneNumber telephoneNumber()
        {
            return TelephoneNumber(getChild(1));
        }
        EmailAddress emailAddress()
        {
            return EmailAddress(getChild(2));
        }
        CompanyName companyName()
        {
            return CompanyName(getChild(3));
        }
        CompanyRole companyRole()
        {
            return CompanyRole(getChild(4));
        }
        static constexpr const char* TypeName() { return "contact_info"; }
    };
}
#endif