Skip to content
Snippets Groups Projects
Select Git revision
  • d929ec32226d678734f7e0e904412323d9e7ee0a
  • master default protected
  • release/201811
  • release/201812
  • release/201901
  • release/201902
  • release/201903
  • release/201904
  • release/201905
  • release/201906
  • release/201908
  • release/201912
  • release/202001
  • release/202005
  • release/windows-test/201910
  • release/201808
  • wip/smartlist_refacto
  • wip/patches_poly_2017/JimmyHamel/MathieuGirouxHuppe
18 results

AccountsViewModel.cpp

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    AccountsViewModel.cpp 10.78 KiB
    /***************************************************************************
     * Copyright (C) 2016 by Savoir-faire Linux                                *
     * Author: Jger Nicolas <nicolas.jager@savoirfairelinux.com>              *
     * Author: Traczyk Andreas <andreas.traczyk@savoirfairelinux.com>          *
     *                                                                         *
     * This program is free software; you can redistribute it and/or modify    *
     * it under the terms of the GNU General Public License as published by    *
     * the Free Software Foundation; either version 3 of the License, or       *
     * (at your option) any later version.                                     *
     *                                                                         *
     * This program is distributed in the hope that it will be useful,         *
     * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
     * GNU General Public License for more details.                            *
     *                                                                         *
     * You should have received a copy of the GNU General Public License       *
     * along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
     **************************************************************************/
    
    #include "pch.h"
    #include "AccountsViewModel.h"
    
    using namespace RingClientUWP;
    using namespace ViewModel;
    
    using namespace Windows::UI::Core;
    
    AccountsViewModel::AccountsViewModel()
    {
        accountsList_ = ref new Vector<Account^>();
        contactListModels_ = ref new Map<String^, ContactListModel^>();
    
        RingD::instance->incomingAccountMessage +=
            ref new RingClientUWP::IncomingAccountMessage(this, &AccountsViewModel::OnincomingAccountMessage);
        RingD::instance->incomingMessage +=
            ref new RingClientUWP::IncomingMessage(this, &AccountsViewModel::OnincomingMessage);
    }
    
    void
    AccountsViewModel::raiseContactAdded(String^ accountId, Contact ^ contact)
    {
        contactAdded(accountId, contact);
    }
    
    void
    AccountsViewModel::raiseContactDeleted(String^ accountId, Contact ^ contact)
    {
        contactDeleted(accountId, contact);
    }
    
    void
    AccountsViewModel::raiseContactDataModified(String^ accountId, Contact ^ contact)
    {
        contactDataModified(accountId, contact);
    }
    
    void
    AccountsViewModel::raiseUnreadContactRequest()
    {
        newUnreadContactRequest();
    }
    
    Account^
    AccountsViewModel::addRingAccount(  std::string& alias,
                                        std::string& ringID,
                                        std::string& accountID,
                                        std::string& deviceId,
                                        std::string& deviceName,
                                        bool active,
                                        bool upnpState,
                                        bool autoAnswer,
                                        bool dhtPublicInCalls,
                                        bool turnEnabled,
                                        std::string& turnAddress)
    {
        auto account = ref new Account( Utils::toPlatformString(alias),
                                        Utils::toPlatformString(ringID),
                                        "RING",
                                        Utils::toPlatformString(accountID),
                                        Utils::toPlatformString(deviceId),
                                        Utils::toPlatformString(deviceName),
                                        active,
                                        upnpState,
                                        autoAnswer,
                                        dhtPublicInCalls,
                                        turnEnabled,
                                        Utils::toPlatformString(turnAddress),
                                        "" /* sip hostame not used with ring account */,
                                        "" /* sip username not used with ring account */,
                                        "" /* sip password not used with ring */ );
        RingD::instance->lookUpAddress(accountID, Utils::toPlatformString(ringID));
        accountsList_->InsertAt(0, account);
        contactListModels_->Insert(account->accountID_, ref new ContactListModel(account->accountID_));
        accountAdded(account);
        return account;
    }
    
    Account^
    AccountsViewModel::addSipAccount(   std::string& alias,
                                        std::string& accountID,
                                        bool active,
                                        std::string& sipHostname,
                                        std::string& sipUsername,
                                        std::string& sipPassword)
    {
        auto account = ref new Account( Utils::toPlatformString(alias),
                                        "" /* ring Id not used with sip */ ,
                                        "SIP",
                                        Utils::toPlatformString(accountID),
                                        "" /* device id not used with sip */,
                                        "" /* device name not used with sip */,
                                        active,
                                        false /* upnpn not used with sip */,
                                        false,
                                        true,
                                        false,
                                        "",
                                        Utils::toPlatformString(sipHostname),
                                        Utils::toPlatformString(sipUsername),
                                        Utils::toPlatformString(sipPassword));
    
        accountsList_->InsertAt(0, account);
        contactListModels_->Insert(account->accountID_, ref new ContactListModel(account->accountID_));
        accountAdded(account);
        return account;
    }
    
    void
    AccountsViewModel::clearAccountList()
    {
        accountsList_->Clear();
        clearAccountsList();
    }
    
    Account ^ RingClientUWP::ViewModel::AccountsViewModel::findItem(String ^ accountId)
    {
        for each (Account^ item in accountsList_)
            if (item->accountID_ == accountId)
                return item;
    
        return nullptr;
    }
    
    Account^
    AccountsViewModel::findAccountByRingID(String ^ ringId)
    {
        for each (Account^ item in accountsList_)
            if (item->ringID_ == ringId)
                return item;
    
        return nullptr;
    }
    
    ContactListModel^
    AccountsViewModel::getContactListModel(std::string& accountId)
    {
        if (contactListModels_->Size)
            return contactListModels_->Lookup(Utils::toPlatformString(accountId));
        return nullptr;
    }
    
    int
    AccountsViewModel::unreadMessages(String ^ accountId)
    {
        int messageCount = 0;
        auto acceptIncognitoMessages = findItem(accountId)->_dhtPublicInCalls;
        if (auto contactListModel = getContactListModel(Utils::toString(accountId))) {
            for each (auto contact in contactListModel->_contactsList) {
                if (acceptIncognitoMessages || contact->_trustStatus == TrustStatus::TRUSTED)
                    messageCount += contact->_unreadMessages;
            }
        }
        return messageCount;
    }
    
    int
    AccountsViewModel::unreadContactRequests(String ^ accountId)
    {
        int contactRequestCount = 0;
        if (auto contactListModel = getContactListModel(Utils::toString(accountId))) {
            for each (auto contact in contactListModel->_contactsList) {
                if (contact->_trustStatus == TrustStatus::INCOMING_CONTACT_REQUEST) {
                    contactRequestCount += contact->_unreadContactRequest ? 1 : 0;
                }
            }
        }
        return contactRequestCount;
    }
    
    int
    AccountsViewModel::bannedContacts(String^ accountId)
    {
        int bannedContacts = 0;
        if (auto contactListModel = getContactListModel(Utils::toString(accountId))) {
            for each (auto contact in contactListModel->_contactsList) {
                if (contact->_trustStatus == TrustStatus::BLOCKED) {
                    bannedContacts++;
                }
            }
        }
        return bannedContacts;
    }
    
    int
    AccountsViewModel::activeAccounts()
    {
        int totalActiveAccounts = 0;
        for (auto account : accountsList_) {
            if (account->_active)
                totalActiveAccounts++;
        }
        return totalActiveAccounts;
    }
    
    void
    AccountsViewModel::OnincomingAccountMessage(String ^ accountId, String ^ fromRingId, String ^ payload)
    {
        auto contactListModel = getContactListModel(Utils::toString(accountId));
    
        auto contact = contactListModel->findContactByRingId(fromRingId);
    
        bool itemSelected = false;
        if (auto selectedItem = SmartPanelItemsViewModel::instance->_selectedItem)
            itemSelected = (selectedItem->_contact == contact);
        auto isInBackground = RingD::instance->isInBackground;
    
        if (contact == nullptr) {
            contact = contactListModel->addNewContact(fromRingId, fromRingId, TrustStatus::UNKNOWN, true);
            RingD::instance->lookUpAddress(Utils::toString(accountId), fromRingId);
            if (!itemSelected || isInBackground || RingD::instance->isInvisible) {
                RingD::instance->unpoppedToasts.insert(std::make_pair(contact->ringID_,
                    [isInBackground, fromRingId, payload](String^ username) {
                    RingD::instance->ShowIMToast(isInBackground, fromRingId, payload, username);
                }));
            }
        }
        else {
            contact->_isIncognitoContact = true;
            if (!itemSelected || isInBackground || RingD::instance->isInvisible) {
                RingD::instance->ShowIMToast(isInBackground, fromRingId, payload);
            }
        }
    
        auto messageId = Utils::toPlatformString(Utils::genID(0LL, 9999999999999999999LL));
        contact->_conversation->addMessage(MSG_FROM_CONTACT, payload, std::time(nullptr), false, messageId);
    
        /* save contacts conversation to disk */
        contact->saveConversationToFile();
    
        auto item = SmartPanelItemsViewModel::instance->_selectedItem;
        auto selectedContact = (item) ? item->_contact : nullptr;
        newUnreadMessage(contact);
    }
    
    void
    AccountsViewModel::OnincomingMessage(String ^callId, String ^payload)
    {
        auto itemlist = SmartPanelItemsViewModel::instance->itemsList;
        auto item = SmartPanelItemsViewModel::instance->findItem(callId);
        auto contact = item->_contact;
        auto contactListModel = getContactListModel(Utils::toString(contact->_accountIdAssociated));
    
        /* the contact HAS TO BE already registered */
        if (contact) {
            auto item = SmartPanelItemsViewModel::instance->_selectedItem;
    
            auto messageId = Utils::toPlatformString(Utils::genID(0LL, 9999999999999999999LL));
            contact->_conversation->addMessage(MSG_FROM_CONTACT, payload, std::time(nullptr), false, messageId);
    
            /* save contacts conversation to disk */
            contact->saveConversationToFile();
    
            auto selectedContact = (item) ? item->_contact : nullptr;
    
            newUnreadMessage(contact);
        }
    }