password management – Are there remote exploits that are easier to perpetrate than installing a keylogger on a standard win10 laptop?

I’m trying to improve my wife’s password hygiene, and have now finally got her to use different passwords for different sites. She now has trouble remembering to keep the book of them to hand. She flatly refuses to learn to use another program, like KeePass (Excel, Zoom and a web browser are pretty much her limit).

Even using a password manager, malicious installation of a keylogger would be game over for bank details and the like.

System and use. ADSL router with its standard ‘firewall’, wifi to several machines including her win10, with the standard Microsoft Security running on it, updates accepted when offered, but no third party antivirus. No illegal or even unusual browsing done on it, it’s just used for online shopping, banking, facebook and zoom. It doesn’t leave the house, and doesn’t get used with random USB sticks. She seems reasonably savvy about phishing, and often asks for my approval before opening emails. I am the only admin user on it.

What exploits could access a simple unencrypted notepad file of passwords on her machine? How much more dangerous is that to have than an encrypted file or a password manager? The only one that springs to mind is having the machine stolen or lost, unless it’s possible to remotely access files without actually installing software.

Content Management

As well as keeping the music to your liking, In Store Music means you also control any messages your customers hear. You certainly can’t achieve that degree of content management if there’s a radio DJ at the helm.

.

{Global Host IT Smart} Register Your Domain & Save Big|Advanced DNS Management – Hosting, VPN, Proxies

Host IT Smart brings a Cheap Domain Registration offer, which provides enormous domain name options to choose from at best pricing with unique features. Choose an identity for your website & make your brand popular on the internet. 

Below is the pricing of some popular domains by Host IT Smart

  • .com: $9.04
  • .net: $16.44
  • .org: $14.83
  • .in: $11.15
  • .co.in: $8.94
  • .co: 30.65

Features Included with Host IT Smart

  • Inclusion of WHOIS Privacy
  • 24*7 Technical Assistance
  • Simple to use Control Panel
  • Advanced DNS Management
  • TLDs are also available

Our Support Team is prepared to help you in any circumstance and anytime to tackle any issue in the best possible manner. We additionally furnish Instant Talk administration to interact with you, virtually.

For Immediate Assistance or information, contact us: info@hostitsmart.com or visit our website for live chat. 
 

dart – Flutter state and Screen management via runApp()

I use runApp() to change all the screens in my flutter App, but I have the feeling it is bad practice since I never saw anyone do it (I just think its an easy and fast way to change screen or refresh the current screen from an widget in another class whithout using key for setState() function). I never noticed any performance flaws from doing so and it works fine.
Are there reasons to use something different like Navigator etc?

looking for a script – Which Content Management System (CMS)/Wiki should I use?

The Webmasters FAQ outlines the nature of acceptable questions for this site: researching available solutions and providing anecdotal advice falls outside the purpose of this StackExchange site, so this type of question would be better-suited to chat or another discussion forum.

That being said, there are a variety of free and open source content management systems, as well as licensed software and paid services, which may meet your requirements.

Some of the most popular content management systems include:

  • WordPress (PHP, free and open source) – a blogging platform which has expanded to include many other features – See the wordpress stackexchange if you have any questions.
  • Joomla (PHP, free and open source)
  • Drupal (PHP, free and open source) – See the drupal stackexchange if you have any questions.
  • DotNetNuke (ASP, proprietary or free and open source option)
  • MediaWiki (PHP, free and open source) – the software that powers Wikipedia
  • Umbraco (MVC.NET, open source)
  • DokuWiki (PHP, free and open source) – a simple but powerful wiki software
  • Typo3 (PHP, Open Source (GPL)) – powerful for medium and large projects

All of the content management systems listed above are built around the concept of plug-ins which extend the application’s functionality—there are many plug-ins, with new plug-ins authored every day.

Sites like The CMS Matrix and WikiMatrix can help you compare CMS’s (but is best suited for looking for very particular combinations of requirements).

If you have researched content management systems and available plug-ins but cannot find anything that will meet your needs, you should consult a developer who can build something to your specifications either as a plug-in for an existing content management system or as a stand-alone application.

24×7 Web Hosting Support & Server Management | NewProxyLists

24×7 Web Hosting Support & Server Management

Netedge Technology is dealing with webhosting support services since more than 14 years. We are providing webhosting support services through email, chat, tickets and phone. We are expert in management of different kind of servers like.

• Dedicated Server

• Shared Hosting Server

• Reseller Hosting Server

• VPS Hosting Server

• Cloud Hosting Server

We also provide chat and ticketing support to web hosting companies. We use the chat and ticketing system of the client and provide support to client’s clients. We act as an employee of the client for client’s clients.

Please follow this page to get more details about web hosting support package.

Order Now

So, we can take care of any kind of hosting environment. We have been providing 24×7 support to the web hosting clients by providing staffing services like

• Dedicated Technical Staff

• Shared Technical Staff

Please follow this page to get more details about Staffing Services package.

Dedicated Technical Staff

Shared Technical Staff

Control Panels We deal with

CPanel, Plesk, WebsitePanel, Inerworx, DotNet Panel, DirectAdmin, ISPCP, Helm, Hosting Controller and more.

List of other services we are dealing with.

Server Management

Linux Server Management

Windows Server Security

Control Panel Security

Game Server Management

PCI Compliance

Dedicated Staffing

Shared Staffing

Remote Desktop Support

Technical Support

Hourly Technical Support

Ticket & Chat Support

One Time Service

Software Development

Virtualization Management

VPS Server Management

VPS Node Management

Web Hosting Support

Control Panel Management

Datacenter Management

IT Infrastructure Automation

Remote Infrastructure Management

Cloud Infrastructure Management

NOC Management

Web Application Management

Mobile Application Management

IOT Application Management

Please feel free to contact us at

[email protected] if in case of any question.

Website = https://www.netedgetechnology.com

database design – Data modelling and openAPI3.0 for customer and license management – when to know how to split entities?

I’m working on a unique ERP + Ecommerce which is a mix of “Shopify meets Adobe Cloud admin”.
Current project: ancient php framework with MVC, no architecture, resembles a procedural website
Refactor objective: switch architecture to MVVM using OpenAPI to generate proxy classes

When redesigning with OpenAPI and doing database normalization
How entities should be separated from each other?

Entity:

Company
Account Owner
Account Member
License Ownership
License Assigment (in use like a seat)
Shipping Address
Shipping Country
Taxes
Billing Address

How should I structure the openapi and database model?
In the case of taxes, for example, I need to know all of these

    "Province_State_Tax_Id": "1",
    "Province_State_Name": "Alberta",
    "Province_State_Abbreviation": "AB",
    "Province_State_Tax": "5.00",
    "Country_Id": 38

But I also need to query extra things such as who is the owner of the account, but at the same time maintaining the organization separated from owner (that person could leave the company if it’s an employee). I have functions such as license transfer from one account to another, dealers.

Should I make all those parts separate, then compose them together? When to know when it’s too much separation and too little?

c++ – Object Oriented Library Management System

Library management system is a object oriented program that takes care of the basic housekeeping of a library.
This is the third part of a series. The first iteration of the project is found here and the second iteration is also found here

The major actors are the Librarian, Member, and the System.

Major Concern

I made member and Librarian friends of the system class and also composed the system class with Librarian and Member. I felt “System is composed of a Librarian and members” sounds better than “System is a friend of a Librarian and members”. Does this follow the common design patterns?

In my previous post, I wasn’t cleared well enough on why a std::vector should be preferable than std::list in this situation due to the fact that the system would perform insertion frequently. Would std::vector be more scalable and versatile whilst taking speed and efficiency into consideration?

Any other observation on potential pitfalls, traps and common bad practice can be pointed out.

Date.hh

#ifndef DATE_HH
#define DATE_HH

class Date {
    friend std::ostream &operator<<( std::ostream &, const Date & );
     private:
        /* data-members */
        unsigned month = 1;
        unsigned day = 1;
        unsigned year = 1970;

        /* utility functions */
        bool validateDate( unsigned m, unsigned d = 1, unsigned y = 1970 );
        bool checkDay( unsigned m, unsigned d, unsigned y ) const;
        bool isLeapYear( unsigned y ) const { return ( y % 400 == 0 ) || ( y % 4 == 0 && y % 100 != 0 ); }
    public:
        static constexpr unsigned int monthsPerYear = 12;

        /* ctors */
        Date() = default;
        Date( unsigned m, unsigned d, unsigned y );
        Date( unsigned m );
        Date( unsigned m, unsigned d );
        
        /* copy operations */
        Date( const Date &d ) = default;
        Date &operator=( const Date &d ) = default;

        /* equality test operations */
        bool operator==( const Date &d ) const;
        bool operator!=( const Date &d ) const { return !( *this ==  d ); }

        /* method-functions */
        void setDate( unsigned m = 1, unsigned d = 1, unsigned y = 1970 );
        unsigned  getMonth() const;
        unsigned getDay() const;
        unsigned  getYear() const;       
        void nextDay();
        const std::string toString() const;

        // dtor
        ~Date(){};
};

#endif

Date.cc

#include <iostream>
#include <string>
#include <stdexcept>
#include <array>
#include "../headers/Date.hh"

Date::Date( unsigned m, unsigned d, unsigned y ) { 
    if ( validateDate(m, d, y ) ) {
        month = m; day = d; year = y;
    }
}

Date::Date( unsigned m ) {
    if( validateDate( m ) )
        month = m;
}

Date::Date( unsigned m, unsigned d ) {
    if ( validateDate( m, d ) ) {
        month = m; day = d;
    }
}

void Date::setDate( unsigned m, unsigned d, unsigned y ) {
    if ( validateDate( m, d, y ) ) {
        month = m; day = d; year = y;
    }
}

void Date::nextDay() {
    day += 1;
    try {
        checkDay( month, day, year );
    } catch ( std::invalid_argument &e ) {
        month += 1;
        day = 1;
    }
    if ( month % 12 == 0 ) {
        year += 1;
        month = 1;
    }
}
bool Date::operator==( const Date &d ) const {
    if( month != d.month ) return false;
    if ( day != d.day ) return false;
    if ( year != d.year ) return false;

    return true;
}

std::ostream &operator<<( std::ostream &os, const Date &d ) {
    os << d.month << "/" << d.day << "/" << d.year;

    return os;
} 

// utility function
bool Date::validateDate( unsigned m, unsigned d, unsigned y ) {
    // validate month
    if ( m < 1 || m >= 13 )
        throw std::invalid_argument( "Month must be between 1-12" );

    // validate day
    if ( checkDay( m, d, y ) == false )
        throw std::invalid_argument( "Invalid day for current month and year" );
    
    // validate year
    if ( y < 1970 )
        throw std::invalid_argument( "year must be greater than 1969" );
    
    return true;
}

 const std::string Date::toString() const {
     return std::to_string(month) + "/" + std::to_string(day) + "/" + std::to_string(year);
 }

bool Date::checkDay( unsigned testMonth, unsigned testDay, unsigned testYear ) const {
    static const std::array < unsigned, monthsPerYear + 1 > daysPerMonth = { 0,31,28,31,30,31,30,31,31,30,32,30,31};

    if ( testDay > 0 && testDay <= daysPerMonth( testMonth ) )
        return true;
    
    if ( testMonth == 2 && testDay == 29 && isLeapYear( testYear ) ) 
        return true;
    return false;
}

BookItem.hh

#ifndef BOOKITEM_HH
#define BOOKITEM_HH

#include <iostream>
#include <string>
#include <string_view>
#include "Date.hh"

enum class BookStatus : unsigned { RESERVED, AVAILABLE, UNAVAILABLE, REFERENCE, LOANED, NONE };
enum class BookType : unsigned { HARDCOVER, MAGAZINE, NEWSLETTER, AUDIO, JOURNAL, SOFTCOPY };

class BookItem {
    friend std::ostream &operator<<( std::ostream &, const BookItem & );

    private:
        /* data-members */
        std::string title;
        std::string author;
        std::string category;
        Date pubDate;
        std::string isbn;
        BookStatus status;
        BookType type;

        /* user connected to this book */
        std::string bookcurrentUser;

    public:
        /* ctors */
        BookItem() = default;
        BookItem( const std::string &title, const std::string &author, const std::string &cat, const Date &pubDate, 
                const std::string &isbn, const BookType type,  const BookStatus status = BookStatus::AVAILABLE ); 

        bool operator==( const BookItem &bookItem ) const;
        bool operator!=( const BookItem &bookItem ) const { return !( *this == bookItem); };

        /* method-functions */
        void setStatus( BookStatus s ) { status = s; };
        void setType( BookType t ) { type = t;};
        void setCategory( const std::string &c ) { category = c; }
        void setBookCurrentUser( std::string userName ) { bookcurrentUser = userName; }
        std::string_view getBookCurrentUser() const { return bookcurrentUser; }
        std::string_view getStatus() const;
        std::string_view getType() const;
        std::string_view getTitle() const { return title; }
        std::string_view getAuthor() const { return author; }
        std::string_view getCategory() const { return category; };
        std::string_view getIsbn() const { return isbn; }
        Date &getPubDate() { return pubDate; }
        void printPubDate() const { std::cout << pubDate; } 
        const BookStatus getStatusByEnum() const { return status; }
        const BookType getTypeByEnum() const { return type; }

        // dtor
        ~BookItem() = default;
};
#endif

BookItem.cc


#include <iostream>
#include "../headers/BookItem.hh"

BookItem::BookItem( const std::string &t, const std::string &a, const std::string &c, const Date &d, 
                const std::string &i, const BookType ty, const BookStatus s ) {
                    title = t, author = a, category = c, pubDate = d, isbn = i;
                    setStatus( s );
                    setType( ty );
}

bool BookItem::operator==( const BookItem &bookItem ) const {
    if ( title != bookItem.title ) return false;
    if ( author != bookItem.author ) return false;
    if ( category != bookItem.category ) return false;
    if ( pubDate != bookItem.pubDate ) return false;
    if ( isbn != bookItem.isbn ) return false;
    if ( status != bookItem.status ) return false;
    if ( type != bookItem.type ) return false;

    return true;
}

std::string_view BookItem::getStatus() const { 
    switch( status ) {
        case BookStatus::AVAILABLE:
            return "AVAILABLE";
        case BookStatus::REFERENCE:
            return "REFERENCE";
        case BookStatus::UNAVAILABLE:
            return "UNAVAILABLE";
        case BookStatus::LOANED:
            return "LOANED";
        case BookStatus::RESERVED:
            return "RESERVED";
        default:
            return "NONE";
    }
} 

std::string_view BookItem::getType() const {
    switch( type ) {
        case BookType::AUDIO:
            return "AUDIO";
        case BookType::HARDCOVER:
            return "HARDCOVER";
        case BookType::JOURNAL:
            return "JOURNAL";
        case BookType::MAGAZINE:
            return "MAGAZINE";
        case BookType::NEWSLETTER:
            return "NEWSLETTER";
        case BookType::SOFTCOPY:
            return "SOFTCOPY";
        default:
            return "NONE";
    }
}

std::ostream &operator<<( std::ostream &os, const BookItem &b ) {
        os << "nName of book: " << b.getTitle();
        os << "nAuthor of book: " << b.getAuthor();
        os << "nBook category: " << b.getCategory();
        os << "nPublication date: " << b.pubDate;
        os << "nISBN number: " << b.getIsbn();
        os << "nStatus of book: " << b.getStatus();
        os << "nType of book: " << b.getType();
        return os;
}

Librarian.hh

#ifndef LIBRARIAN_HH
#define LIBRARIAN_HH

#include <iostream>
#include <string>
#include "BookItem.hh"

class System;

class Librarian {
    public:
        /* data-members */
        std::string name;
        Date dateOfHire;

        /* ctors */
        Librarian() = default;
        Librarian( const std::string &name, const Date &dateOfHire );

        // basic method-function
        void printDateOfHire() const { std::cout << dateOfHire; }

        /* core functionalities */
        void addBook( System &sys, const BookItem &isbn );
        void removeBook( System &sys, const std::string &isbn );
        void auditLibrary( const System &sys ) const;

        // dtor
        ~Librarian(){}
};

#endif

Librarian.cc

#include <iostream>
#include "../headers/System.hh"
#include "../headers/Librarian.hh"

Librarian::Librarian( const std::string &n, const Date &d ) {
    name = n;
    dateOfHire = d;
}

void Librarian::addBook(System &sys, const BookItem &book ) { 
    if ( sys.books.empty() ) {
        sys.books.push_front( book );
        return;
    }
    for ( auto bptr = sys.books.cbegin(); bptr != sys.books.cend(); ++bptr ) {
        if( book.getTitle() <= bptr->getTitle() ) {
            sys.books.insert(bptr, book);
            return;
        }
    }
    sys.books.push_back( book );
}

void Librarian::removeBook( System &sys, const std::string &isbn ) {
    BookItem book = sys.getBook( isbn );
    for ( auto bptr = sys.books.cbegin(); bptr != sys.books.cend(); ++bptr ) {
        if ( book.getIsbn() == bptr->getIsbn() ) {
            sys.books.remove(book);
            std::cout << "Deleted { " << book.getAuthor() << " : " << book.getTitle() << " } n";
            return;
        }
    }
    throw std::invalid_argument("Book not found");
}

void Librarian::auditLibrary( const System &sys ) const {
    std::cout << "nName of Library: " << sys.libraryName << ", Date created " << sys.dateCreated;
    std::cout << "nLibrarian: " << name << ", Date of hire: " << dateOfHire;
    std::cout << "nnBooks: ";
    for ( auto bptr = sys.books.cbegin(); bptr != sys.books.cend(); ++bptr ) {
        std::cout << *bptr << "n";
        std::cout << "This book is linked to: " 
                << ( ( bptr->getBookCurrentUser() == "" ) ? "None" : bptr->getBookCurrentUser() ) << "n"; 
    }
    std::cout << "nnMembers: ";
    for ( auto mPtr = sys.members.cbegin(); mPtr != sys.members.cend(); ++mPtr ) {
        std::cout << *mPtr << "n";
    }
}

Member.hh

#ifndef MEMBER_HH
#define MEMBER_HH

#include <string>
#include <vector>
#include "Date.hh"
#include "BookItem.hh"

class System;

class Member {
    friend std::ostream& operator<<( std::ostream&os, const Member &m );

    private:
        /* data-member */
        std::string libraryNumber;
        Date dateRegisted;
        std::vector<BookItem> checkedOutBooks;

    public:
        /* data-member */
        std::string name;
        char sex;
        /* ctors */
        Member() = default;
        Member( const std::string &n, const char s, Date d ) : dateRegisted( d ), name( n ), sex( s ) {}
        
        /* method-functions */
        std::string getLibraryNumber() const { return libraryNumber; }
        void setLibraryNumber( const std::string &lNum ) { libraryNumber = lNum; };
        void checkOut( System &sys, const std::string &isbn );
        void returnBook( System &sys, const std::string &isbn );
        bool operator==( const Member &m );
        bool operator!=( const Member &m ) { return !( *this == m ); }

        // dtor
        ~Member() = default;
};

#endif

System.cc

#ifndef SYSTEM_HH
#define SYSTEM_HH

#include <string>
#include <list>
#include <vector>
#include "Date.hh"
#include "BookItem.hh"
#include "Librarian.hh"
#include "Member.hh"

class System {
    friend class Librarian;
    friend class Member;

    private:
        /* data-members */
        std::list<BookItem> books{};
        std::vector<Member> members{};
        Librarian librarian;
        Member member;

    public:
        /* ctors */
        System() = default;
        System( const std::string &name, Date &date ) : libraryName( name ), dateCreated( date ) {};

        /* method-functions */
        const std::string generateLibraryNumber() const;
        void addMember( Member &m ) { members.push_back( m ); };
        void deleteMember( Member &m );
        void displayMembers();
        BookItem getBook( const std::string &isbn ) const;
        void viewBook( const std::string isbn ) const;
        void placeOnReserve( const std::string, const std::string &isbn );
        void displayAllBooks() const;

        /* data-members */
        std::string libraryName;
        Date dateCreated;
    
        
        /* search functionalities */
        std::list<BookItem> queryByTitle( const std::string &t ) const;
        std::list<BookItem> queryByAuthor( const std::string &a ) const;
        std::list<BookItem> queryByPubDate( const Date &d );
        std::list<BookItem> queryByStatus( const BookStatus &s ) const;
        std::list<BookItem> queryByType( const BookType &ty ) const;

        // dtor
        ~System() = default;
};

#endif

System.cc

#include <iostream>
#include <set>
#include "../headers/System.hh"

std::list<BookItem> System::queryByTitle( const std::string &t ) const {
    std::list<BookItem> queryList;
    for ( auto bPtr = books.cbegin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getTitle().find(t) != std::string::npos )
           queryList.push_back( *bPtr );
    }
    return queryList;
}

std::list<BookItem> System::queryByAuthor( const std::string &a ) const {
    std::list<BookItem> queryList;
     for ( auto bPtr = books.cbegin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getAuthor().find(a) != std::string::npos )
           queryList.push_back( *bPtr );
    }
    return queryList;
}
std::list<BookItem> System::queryByPubDate( const Date &d ) {
    std::list<BookItem> queryList;
    for ( auto bPtr = books.begin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getPubDate().toString().find(d.toString()) != std::string::npos )
           queryList.push_back( *bPtr );
    }
    return queryList;
}
std::list<BookItem> System::queryByStatus( const BookStatus &s ) const {
    std::list<BookItem> queryList;
    for ( auto bPtr = books.begin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getStatusByEnum() == s )
           queryList.push_back( *bPtr );
    }
    return queryList;
}
std::list<BookItem> System::queryByType( const BookType &ty ) const {
     std::list<BookItem> queryList;
    for ( auto bPtr = books.begin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getTypeByEnum() == ty )
           queryList.push_back( *bPtr );
    }
    return queryList;
}

void System::placeOnReserve( const std::string name, const std::string &isbn )  {
    for ( auto bPtr = books.begin(); bPtr != books.end(); ++bPtr ) {
        if ( bPtr->getIsbn() == isbn ) {
            bPtr->setStatus( BookStatus::RESERVED );
            bPtr->setBookCurrentUser( name );
        }
    }
}

BookItem System::getBook( const std::string &isbn ) const {
    for ( auto bPtr = books.cbegin(); bPtr != books.cend(); ++bPtr ) {
        if ( bPtr->getIsbn() == isbn )
            return *bPtr;
    }
    throw std::invalid_argument("Book is not available at the library");
}

void System::viewBook( const std::string isbn ) const {
    std::cout << getBook( isbn );    
}

const std::string System::generateLibraryNumber() const {
    static std::string Codes(10){"XGS", "QWT", "OPI", "NMK", "DXF", "PXG", "OPI", "QPU", "IKL", "XYX" };
    static std::set< unsigned, std::greater<unsigned> > idSet;
    unsigned id;
    bool unique = false;
    unsigned index = 0 + rand() % 9;
    std::string code = Codes( index );
    while ( unique == false ) {
        id = 10000000 + rand() % 9999999;
        auto ret = idSet.emplace(id);
        if ( !ret.second ) {
            std::cout << "unique failed";
            unique = false;
            continue;
        }
        else 
            unique = true;
    }
    return code + std::to_string( id );
}

void System::deleteMember( Member &m ) {
    for ( auto mPtr = members.begin(); mPtr != members.end(); ++mPtr ) {
        if ( *mPtr == m ) {
            members.erase( mPtr );
            std::cout << "Deleted member: { Name: " << m.name << ", Library Number: " << m.getLibraryNumber() << 
            " }n";
            return;
        }
    }
    throw std::invalid_argument("No such member found");
}

void System::displayMembers() {
    std::cout << "Members of Library: ( count : " << members.size() << " ) " << "n";
    for ( auto mPtr = members.cbegin(); mPtr != members.cend(); ++mPtr ) {
        std::cout << *mPtr;
    }
}
void System::displayAllBooks() const {
    for ( auto bPtr = books.begin(); bPtr != books.end(); ++bPtr ) {
        std::cout << *bPtr <<  "nn";
    }
}
```

encryption – Is centralized key management better or decentralized key management better to prevent attacks on database level?

I was planning to start a project that’s sort of like a hybrid mix of banking system and commercial system.

In such case, considering that I need to encrypt the data at database level with a prevention of both insider’s and outsider’s attack on database as it happens to me data leakage happens quite often..

What are the recommended type of key management to do so and the reason behind it?

object oriented – Library Management System OOP with c++( Part2 of a series )

I don’t know if this is acceptable, but I would love to thank the community for their advice concerning my previous post on this project

This is a beginner’s project.

Library management system aims to handle the basic housekeeping of a functional library, so far I have implemented the BookItem class and with advice from the community, also implemented a Date class( not with full funtionalities )

Librarian class though not completed yet is also functional…
I used a list to store the books in the library. I saw some post where vectors are suggested as the goto data structure, I feel list best suit this case, If vectors would be better I would appreciate if you highlight the reasons.

Note am a beginner and have no knowledge about C++ advanced topics yet.

Here is the code

Date.hh

#ifndef DATE_HH
#define DATE_HH
/*****************************************************************
 * Name: Date.hh
 * Author: Samuel Oseh
 * Purpose: Date class method-function prototype
 * ***************************************************************/
#include <iostream>
class Date {
    friend std::ostream &operator<<( std::ostream &, const Date & );
     private:
        /* data-member */
        unsigned int month;
        unsigned int day;
        unsigned int year;

        // utility function
        unsigned int checkDay( int ) const;

    public:
        static const unsigned int monthsPerYear = 12;

        // ctors
        Date() : Date( 1, 1, 1970 ){}
        Date( int m, int d, int y ) { setDate( m, d, y );}
        Date( int m ) : Date( m, 1, 1970 ){}
        Date( int m, int d ) : Date( m, d, 1970 ) {}
        
        // copy operations
        Date( const Date &d ) { *this = std::move(d); }
        Date &operator=( const Date &d ) { month = d.month; day = d.day; year = d.year; return *this; }

        /* method-functions */
        void setDate( int m, int d, int y );
        void setMonth( int m );
        void setDay( int d );
        void setYear( int y );
        unsigned int getMonth() const;
        unsigned int getDay() const;
        unsigned int getYear() const;       
        void nextDay();

        // dtor
        ~Date(){};
};

#endif

Date.cc

/*****************************************************************
 * Name: Date.cc
 * Author: Samuel Oseh
 * Purpose: Date class method-function definitions
 * ***************************************************************/
#include <iostream>
#include <stdexcept>
#include <array>
#include "Date.hh"

void Date::setDate( int m, int d, int y) {
    setMonth( m );
    setDay( d );
    setYear( y );
}

void Date::setDay( int d ) {
    day = checkDay( d );
}

void Date::setMonth( int m ) {
   if ( m >= 1 && m < 13 )
        month = m;
    else
      throw std::invalid_argument( "Month must be between 1-12" );
}

void Date::setYear( int y ) {
    if ( y >= 1970 )
        year = y;
    else
        throw std::invalid_argument( "year must be greater than 1969" );
}

void Date::nextDay() {
    day += 1;
    try {
        checkDay( day );
    } catch ( std::invalid_argument &e ) {
        month += 1;
        day = 1;
    }
    if ( month % 12 == 0 ) {
        year += 1;
        month = 1;
    }
}

std::ostream &operator<<( std::ostream &os, const Date &d ) {
    os << d.month << "/" << d.day << "/" << d.year << " ";

    return os;
} 

// utility function
unsigned int Date::checkDay( int testDay ) const {
    static const std::array < int, monthsPerYear + 1 > daysPerMonth = { 0,31,28,31,30,31,30,31,31,30,32,30,31};

    if ( testDay > 0 && testDay <= daysPerMonth( month ) )
        return testDay;
    
    if ( month == 2 && testDay == 29 && ( year % 400 == 0 || ( year % 4 == 0 && year % 100 != 0 ) ) )
        return testDay;
    throw std::invalid_argument( "Invalid day for current month and year" );
}

BookItem.hh

#ifndef BOOKITEM_HH
#define BOOKITEM_HH
/*****************************************************************
 * Name: BookItem.hh
 * Author: Samuel Oseh
 * Purpose: BookItem class method-function prototype
 * ***************************************************************/
#include <string>
#include "Date.hh"

enum class BookStatus : unsigned { RESERVED, AVAILABLE, UNAVAILABLE, REFERENCE, LOANED, NONE };
enum class BookType : unsigned { HARDCOVER, MAGAZINE, NEWSLETTER, AUDIO, JOURNAL, SOFTCOPY };

class BookItem {
    private:
        /* data-members */
        std::string title;
        std::string author;
        std::string category;
        Date pubDate;
        std::string isbn;
        BookStatus status;
        BookType type;
    public:
        // ctor
        BookItem() = default;
        BookItem( const std::string &title, const std::string &author, const std::string &cat, const Date &pubDate, 
                const std::string &isbn, const BookStatus status, const BookType type ); 

        // copy operations
        const BookItem& operator=( const BookItem &bookItem );
        BookItem( const BookItem &bookItem ) { *this = std::move(bookItem); }

        /* method-functions */
        void setStatus( BookStatus s ) { status = s; };
        void setType( BookType t ) { type = t;};
        std::string getStatus() const;
        std::string getType() const;
        std::string getTitle() const { return title; }
        std::string getAuthor() const { return author; }
        Date &getPubDate() { return pubDate; }
        void printPubDate() const { std::cout << pubDate; }
        std::string getIsbn() const { return isbn; }
        void setCategory( const std::string &c ) { category = c; }
        std::string getCategory() const { return category; };

        // dtor
        ~BookItem(){}
};
#endif

BookItem.cc

/*****************************************************************
 * Name: BookItem.cc
 * Author: Samuel Oseh
 * Purpose: BookItem class method-function definitions
 * ***************************************************************/
 #include <iostream>
#include "BookItem.hh"

BookItem::BookItem( const std::string &t, const std::string &a, const std::string &c, const Date &d, 
                const std::string &i, const BookStatus s, const BookType ty ) {
                    title = t, author = a, category = c, pubDate = d, isbn = i;
                    setStatus( s );
                    setType( ty );
}

const BookItem &BookItem::operator=( const BookItem &bookItem ) {
    title = bookItem.title;
    author = bookItem.author;
    category = bookItem.category;
    pubDate =  bookItem.pubDate;
    isbn = bookItem.isbn;
    status = bookItem.status;
    type = bookItem.type;

    return *this;
}

std::string BookItem::getStatus() const { 
    if ( status == BookStatus::AVAILABLE )
        return "AVAILABLE";
    else if ( status == BookStatus::REFERENCE )
        return "REFERENCE";
    else if ( status == BookStatus::UNAVAILABLE )
        return "UNAVAILABLE";
    else if ( status == BookStatus::LOANED )
        return "LOANED";
    else if ( status == BookStatus::RESERVED )
        return "RESERVED";
    else
        return "NONE";
} 

std::string BookItem::getType() const {
    if ( type == BookType::AUDIO )
        return "AUDIO";
    if ( type == BookType::HARDCOVER )
        return "HARDCOVER";
    if ( type == BookType::JOURNAL )
        return "JOURNAL";
    if ( type == BookType::MAGAZINE )
        return "MAGAZINE";
    if ( type == BookType::NEWSLETTER )
        return "NEWSLETTER";
    if ( type == BookType::SOFTCOPY )
        return "SOFTCOPY";
    else 
        return "NONE";
}

Librarian.hh

#ifndef LIBRARIAN_HH
#define LIBRARIAN_HH
/*****************************************************************
 * Name: Librarian.hh
 * Author: Samuel Oseh
 * Purpose: Librarian class method-function prototype
 * ***************************************************************/
#include <iostream>
#include <string>
#include "BookItem.hh"
#include <list>

class Librarian {
    private:
        /* data-member */
        std::string name;
        Date dateOfHire;
        std::list<BookItem> *books = new std::list<BookItem>;
    public:
        // ctor
        Librarian() = default;
        Librarian( const std::string &name, const Date &dateOfHire );

        /* basic method-functions */
        void setName( const std::string &name );
        void setDateOfHire( const Date &date );
        std::string getName() const { return name; };
        Date &getDateOfHire() { return dateOfHire; }
        void printDateOfHire() const { std::cout << dateOfHire; }

        /* core functionalities */
        void addBook( const BookItem &book );
        void auditLibrary() const;
        
        // dtor
        ~Librarian(){}
};

#endif

Librarian.cc

/*****************************************************************
 * Name: Librarian.cc
 * Author: Samuel Oseh
 * Purpose: Librarian class method-function definitions
 * ***************************************************************/

#include <iostream>
#include "Librarian.hh"

Librarian::Librarian( const std::string &n, const Date &d ) {
    name = n;
    dateOfHire = d;
}

void Librarian::setName( const std::string &n ) {
    name = n;
}

void Librarian::setDateOfHire( const Date &d) {
    dateOfHire = d;
}

void Librarian::addBook( const BookItem &book ) { 
    if ( books->empty() ) {
        books->push_front( book );
        return;
    }
    for ( auto bk = books->begin(); bk != books->end(); ++bk ) {
        if( book.getTitle() <= bk->getTitle() ) {
            books->insert(bk, book);
            return;
        }
    }
    books->push_back( book );
}

void Librarian::auditLibrary() const {
    std::cout << "Librarian: " << name << ", Date of hire: " << dateOfHire;
    std::cout << "nnBooks:";
    for ( auto bk = books->begin(); bk != books->end(); ++bk ) {
        std::cout << "nName of book: " << bk->getTitle();
        std::cout << "nAuthor of book: " << bk->getAuthor();
        std::cout << "nBook category: " << bk->getCategory();
        std::cout << "nPublication date: ";
        bk->printPubDate();
        std::cout << "nISBN number: " << bk->getIsbn();
        std::cout << "nStatus of book: " << bk->getStatus();
        std::cout << "nType of book: " << bk->getType();
        std::cout << "nn"; 
    }
}