Beginning Power Apps: The Non-Developer's Guide to Building Business Applications

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Foreword
Introduction
Part I: Power Apps Fundamentals
	Chapter 1: Introducing Power Apps
		What Is Power Apps?
		The History of Power Apps
		What Are the Key Benefits of Power Apps?
		What Data Sources Can We Use?
		Sample Apps
			Canvas Apps
				Asset Checkout App
				Budget Tracker
				Service Desk App
				Site Inspection App
				Other Sample Apps
			Model-Driven Apps
			Portal Apps
		How Do We Build a Power Apps Application?
		How Do Users Run Power Apps Applications?
		How Do We Write Code?
		Summary
	Chapter 2: Subscribing to Power Apps
		How to Get Power Apps
		Which Plan Do I Need to Access a Data Source?
		Subscribing to Power Apps
			Obtaining a Suitable Email Address
			What Are the Licensing Options?
			Licensing Portal and AI Builder Apps
		Accessing Power Apps via Microsoft/Office 365
			What Is Office 365?
			Microsoft 365: Consumer vs. Business Plans
			Understanding Work Accounts and Personal Accounts
			Which Microsoft/Office 365 Plans Include Power Apps?
				Microsoft 365 Business Plans: Features and Prices
				Office 365 Enterprise Plans: Features and Prices
			Does the Plan I Want to Buy Include Power Apps?
		Accessing Power Apps via Dynamics 365
			What Is Dynamics 365?
			How Much Does It Cost?
		Logging On to Power Apps
			Creating an App
			Overview of Other Administrative Areas
			Reviewing Our Entitlements
		Summary
	Chapter 3: Creating Your First App
		Preparing an Excel Data Source
		Creating an App
		Creating an Auto-generated App
			Creating Apps from SharePoint
		Exploring the Designer
		Running Your App
			Examining the Screens at Runtime
		Understanding the Auto-generated App
			Adding and Removing Data Sources
			Adding, Deleting, and Rearranging Screens
			Understanding How Screens Are Connected
				How the Browse Screen Works
				How the Details Screen Works
				Searching for Controls
				How the Edit Screen Works
			Understanding Forms and Cards
				Adding Fields to a Form
				Reading Data into a Form
					How Card Controls Work
				Saving Form Data to a Data Source
				Choosing Not to Use Forms and Cards
				Recap of Concepts
		Setting App Properties
		Saving and Opening Apps
		Summary
	Chapter 4: Sharing Apps
		Sharing Apps with End Users
			Specifying Owners and Users
			Creating Users
			Setting Up Security Groups
			Setting Up External Users
		Sharing App Data Sources
		Running Apps
			Installing the Mobile Player
		Understanding Environments
			Creating New Environments
			Choosing an Environment Type
			Setting Environment Permissions
		Moving Apps Between Environments and Tenants
			Exporting an App
			Importing an App
			Updating a Data Source
		Versioning Apps
		Running with Foreign Languages
		Summary
	Chapter 5: Using Formulas
		Writing Formulas
			Adding Comments
		Working with Variables
			Setting Screen Variables
				Example of Context Variables
				Passing Values to Screens
			Setting Property Values from Code
			Setting Global Variables
		Working with Basic Data Types
			Working with Text
				Text Manipulation Functions
				Modifying the Casing of Sentences
				Replacing Text
				Searching Within Strings
				Matching String Patterns
				Matching with Regular Expressions
				Extracting Text with Regular Expressions
				Stripping Characters with Regular Expressions
			Working with Numbers
				Formatting Numbers
				Rounding Functions
				Trigonometric Functions
				Other Mathematical Functions
			Working with Dates
				Formatting Dates and Times
				Performing Date Arithmetic
				Importing Static Dates
				Calendar Functions
		Conditional Statements and Logical Operations
			Calling the Switch Function
		Color Functions
		Navigation Functions
			Launching Websites and Apps
			Retrieving Start-Up Parameters
			Exiting an App
		Managing Errors
		Summary
Part II: Working with Data
	Chapter 6: Setting Up SharePoint, SQL, and More
		What’s the Best Data Source?
		Using a SharePoint Data Source
			Creating a SharePoint List
				Choice Items
			Understanding SharePoint Special Columns
			SharePoint Conflict Management
			Connecting to a SharePoint Data Source
				Connecting to Other SharePoint Apps
		Building SharePoint Forms
		SQL Server
			SQL Server Limitations
			Setting Up SQL Azure
			Managing a SQL Database
			SQL Database Views
		On-Premises Data Gateway
			Installing the Gateway
			Starting the Gateway Service
			Connecting to a Data Source
				Connecting to SQL Server
			Uninstalling a Gateway
		Other Data Sources
			Static Excel Data
			Microsoft Translator Data Source
			Microsoft MSN Weather Services
			Sending Push Notifications
		Summary
	Chapter 7: Working with Tables, Rows, and Collections
		Basic Syntax
		Overview of Collections and Functions
		Working with Collections
			Setting Up Our Demo App
			Adding a Single Row (Uniquely Identifiable)
			Updating a Single Row
			Deleting a Single Row
		Working with Data Sources
			Saving Records That Include SharePoint Lookup Values
				Patching Complex SharePoint Types
			Retrieving Server-Generated Values
			Adding Multiple Child Rows
			Updating Multiple Rows
			Deleting Multiple Rows
		Processing Data Row by Row
			Using ForAll to Build HTML
		Grouping, Counting, and Aggregating Records
			Creating Sequences
			Counting Records
			Aggregate Maths
			Returning Min and Max Records
			Grouping and Aggregating Values
			Ungrouping Records
		Combining Rows (Union Results)
		Splitting Text into Rows
			Splitting CSV Strings
			Splitting and Concatenating Rows
			Building Comma-Separated Strings
			Getting Hashtags
		Summary
	Chapter 8: Searching and Retrieving Data
		Basic Behavior
			Understanding Delegation
			Increasing the Data Row Limit
			How Do Controls Manage Large Quantities of Data?
		Searching Data
			Basic Search Functions
				Filtering by Drop-Down Values
					Providing a “Show All”/Wildcard Option
				Searching by Date Criteria
				Searching by Numeric Criteria
				Searching by Text Criteria
				Adding a Search Button
		Sorting Data by Multiple Columns
		Joining Data
			Joining Records: Showing Related Records
				Aliasing Record Items
		Search Procedures That Can Cause Difficulties
			Matching Against Lists of Data
				Using in to Match Substring Text
			Checking for Nonexistence
			Matching Blank Fields
			Returning Distinct Records
		Resolving Delegation Issues
			SQL Server Views
			SharePoint Columns
		Summary
Part III: Developing Canvas Apps
	Chapter 9: Canvas App Design
		Using Screen Predefined Layouts
			Scrollable Screen Template
			Tutorial Screen Template
			Office 365 Screen Templates
		Icons and Shapes
			Using Icons and Shapes as Buttons
		Using Themes
		Examining Sample Screen Designs
			Building a List and Details Screen
			Updating the Details Section of a Screen
			Displaying a Delete Confirmation Screen
			Building a Tab Control Screen
		Organizing Controls
			Grouping Controls
			Applying a Consistent Appearance
		Phone vs. Tablet Apps
		Supporting Multiple Devices
			Designing a Responsive App
			Formulas That We Use
				Screen Sizes
			Building a Responsive App
				Making Screens Responsive
				Configuring the Gallery Control
				Testing and Building Our App
		Using the Timer Control
		Summary
	Chapter 10: Using Simple Controls
		Chapter Overview
		Building Data Structures to Support Controls
		Displaying Data
			The Label Control
			The HTML Text Control
			Displaying Phone Numbers and Email Addresses
		Using Simple Data Entry Controls
			Text Input Control
			Rich Text Control
			Radio Control
				Storing Radio Control Options in Separate Tables or Collections
			Toggle and Checkbox Controls
			Slider Control
			Rating Control
		Working with Dates
			Date Picker Control
				Showing Dates Only
			Understanding Time Zones
				Excel Walk-Through
				Storing Absolute Times
			Saving Dates in Year-Month-Day Format
		Summary
	Chapter 11: Using Table/Record Data Controls
		Chapter Overview
		Data Entry Controls
			Drop-Down Control
			Setting Lookup Values
				Setting Lookup Values with SharePoint and Dataverse
				Setting Lookup Values with Other Data Sources
			Customizing the Drop-Down Display Value
			Nesting Drop-Down Controls
				Setting Drop-Down Control Dependencies
				Changing the Combo Box Layout
				Defining Drop-Down Dependencies with Formulas
			Selecting Multiple Items with a Combo Box
				Combo Box Multi-selection with SharePoint
				Combo Box Multi-selection with Other Data Sources
		Data Display Controls
			List Box Control
			Displaying Tables of Data
		Working with Gallery Controls
			Choosing a Gallery Type
			Applying Layouts
			Setting Properties
			Incorporating Data Entry Controls
		Working with Forms
			Laying Out a Form
			Defining Form Columns
			Combining Forms and Patch
			Setting Form Default Values
			Resetting Form Controls
			Validating Form Values
		Retrieving Validation Rules
		Summary
Part IV: Developing Model-Driven and Portal Apps
	Chapter 12: Building a Dataverse Database
		Why Use Dataverse?
			What Are the Terms That Are Used?
			The Common Data Model
			How Much Can We Store?
		Creating a Dataverse Database
		Listing Tables
		Editing Tables
		Creating a Custom Table
			Table Settings
		Adding a New Column
			Storing Currencies
			Storing Dates
			Storing Autonumbers
		Defining Relationships
			Setting Up a One-to-Many Relationship
			Setting Up a Many-to-Many Relationship
			Setting Up a Self-Relationship
		Defining Keys
		Choices
			Creating Sets of Choices
		Defining Calculated and Rollup Columns
			Creating Calculated Columns
			Aggregating Figures with Rollup Columns
		Viewing, Editing, and Deleting Data
			Viewing Data
				Managing Views
				Creating a View
			Adding and Editing Data
				Adding and Modifying Forms
		Summary
	Chapter 13: Developing Model-Driven Apps
		Introducing Model-Driven Apps
			Demonstration of a Basic App
			Terminology
		Creating an App
			Uploading Web Resources
		Exploring the Designer
		Setting Up Menus
		Working with Data
			Showing Lists of Data
				Showing Records Assigned to the Current User Only
			Creating and Editing Records
				Laying Out a Form
				Adding Fields and Components
			Validating Data
				Creating a Business Rule
			Building Dashboards
				Creating a Dashboard
				Creating a Classic Dashboard
				Creating an Interactive Dashboard
				Creating an Entity Dashboard
		Building Business Process Flows
		Customizing a Model-Driven App
			Embedded Canvas Apps: Overview
				Designing a Form with the Classic Designer
				Associating a Form Field with a Canvas App Control
				Building and Integrating a Canvas App with a Host Form
				Performing Actions on the Host Form
			Customizing Apps with JavaScript
				Client API: Overview
					Retrieving Field Values
					Accessing Field Attributes
					Accessing Form Attributes
				Example 1: Defaulting to Today’s Date
				Uploading the Script
				Attaching JavaScript Functions to Events
				Example 2: Validating Field values
		Summary
	Chapter 14: Building Portal Apps
		Introduction
			Pricing
		Creating a Portal
			Managing Portal Trials
		Working with the Designer
			Adding Pages
			Navigation Menus
			Designing Web Pages
			Adding Text and Images
			Adding Sections
				Understanding Responsive Areas
		Managing a Portal App
			The Anatomy of a Web Page
			Understanding Page Templates
				Configuring Web Pages and Page Templates
				Setting Website Headers and Footers
			Web Templates
				Inheriting Web Templates
				Inserting the Web Page Content
		Securing a Portal
			Setting Up Login Accounts
			Configuring Authentication Providers
			Controlling Registrations
				Invitation Model
				Confirming Email Addresses
			Setting Up Web Roles
			Controlling Access to Web Pages
			Controlling Access to Dataverse
				Restricting Access to Specific Records
				Restricting Access to Associated Records
				Restricting Profile Access
		Clearing the Cache
		Summary
	Chapter 15: Retrieving Data from Portal Apps
		Working with Data
			Creating Data Entry Pages
			Adding a New Record
			Editing a Record
			Viewing a Record
			Listing Data
		Creating Web Forms
			Creating a Dataverse Form
			Creating a Portal Web Form
			Defining Web Form Steps
			Defining Additional Steps
			Branching Form Steps
			Completing and Running Our Web Form
		Configuring Form Fields
			Validating Fields and Forms
			Setting Default Form Values
			Runtime Example
		Searching Data
		Customizing Content
			Liquid Language
			Retrieving the Current User
			Retrieving a Single Record
			Retrieving Multiple Records
		Customizing Pages with JavaScript
			Uploading JavaScript Files
			Validating Data
		Summary
Part V: Enhancing Apps
	Chapter 16: Working with Images and Media
		Choosing Where to Store Images
		Setting Up a Data Source
			Setting Up an Excel Spreadsheet
			Setting Up a Dataverse Table to Store Images
			Setting Up a SQL Server Table to Store Images
			Setting Up SharePoint
		Creating an Image App
		Using the Camera Control
			Switching Between Cameras
			Setting Brightness, Contrast, and Zoom Levels
		Storing Images in SharePoint
			Working with the Add Picture Control
			Converting Images to Text
			Viewing Data
		Building a Photo Gallery
		Model-Driven Apps
			Uploading and Viewing Images
		Canvas App Features
			Using the Pen Control
				Erasing Text
				Converting Annotations to Text
			Scanning Barcodes
			Working with Media Controls
				Playing Videos
				Playing Audio
				Displaying Images
				Displaying SVG Images
		Summary
	Chapter 17: Storing and Retrieving Files
		Overview
		Storing Files in SharePoint
			Restricting File Types
			Connecting to Document Libraries
		Storing Files in Dataverse
		Storing Files in SQL Server
			Setting Up a SQL Server Table
			Adding and Updating a Record
			Downloading File Attachments
			Deleting a File
		Storing Files in Azure Blob Storage
			Setting Up an Azure Blob Storage Account
			Managing an Azure Blob Storage Account
			Connecting to an Azure Blob Storage Account
				Uploading Files to Azure Blob Storage
				Listing Files in a Container
				Viewing and Retrieving File Content
				Downloading Files
				Deleting Files
		Working with Model-Driven Apps
		Summary
	Chapter 18: Integrating Maps and Location Services
		Introduction to Location Services and GPS
			Longitudes and Latitudes
		Retrieving Location Details
			Introducing Signals
			Freezing the Location Details
			Obtaining Longitude and Latitude Readings
			Saving Location Details
			Switching the Signal On/Off
			Other Signals
		Displaying Maps
			Using Google Maps
			Bing Maps
		Using Azure Maps Services
			Interactive Maps
			Address Suggestion
		Summary
	Chapter 19: Charting Data
		Introduction
		Canvas Apps
			Transforming Data
			Building a Column Chart
				Setting Legends
				Applying Colors and Styles
			Building a Pie Chart
			Building a Line Chart
				Showing Multiple Series
		Model-Driven Apps
			Using the Designer
				Building a Staked Chart
				Combining Charts
			Displaying Charts
			Displaying Dashboards
			Customizing XML
				Customizing the Chart
				Customizing the Data Source
		Summary
	Chapter 20: Adding Artificial Intelligence to Apps
		Introducing Artificial Intelligence
			What Can We Do with AI Builder?
				Processing Images
				Language Processing
				Making Predictions
			Prebuilt Models vs. Custom Models
			Licensing
		Processing Images
			Reading Business Cards
			Recognizing Text
			Detecting Objects
				Detecting Objects from Canvas Apps
			Processing Forms
				Processing Forms from Canvas Apps
		Processing Text
			Analyzing Text with Formulas
				Analyzing Sentiment
				Detecting Languages
				Extracting Key Phrases
			Categorizing Text
				Building a Custom Categorization Model
				Retrieving the Results of a Categorization Model
				Using a Custom Categorization Model in a Canvas App
			Extracting Entities
				Building a Custom Entity Extraction Model
				Using a Custom Model in a Canvas App
		Predicting Outcomes
			Using a Prediction Model
		Summary
Part VI: Reusability
	Chapter 21: Building Reusable Canvas Components
		What Can We Do with Canvas Components?
		Designing a Component
		Where to Define Components
		Creating a Component Library
			Adding Controls to a Component
			Defining Properties
			Setting Property Values
		Adding Components to Apps
		Updating a Component
		Editing a Component
		Exporting and Importing Components
		Importing and Exporting Component Libraries
		Summary
	Chapter 22: Building Reusable Code Components
		What Can We Do?
			Microsoft Samples
			Other Samples
		Quick Guide: An Overview
		Prerequisites
			Installing NPM
			Installing the .NET Framework Developer Pack
			Installing the Command Line Interface (CLI)
			Installing Visual Studio Code
		Creating a Project
			Creating a PCF Project
			Examining Our Project Layout
			Adding Project References
		Developing a Control
			Defining the Control Manifest
			Writing the Code
				TypeScript File Overview
				Defining Presentation/HTML
				Initializing the Control
				Updating Control Values
				Setting Output Values
				Cleaning Up the Control
			Style the Component with CSS
		Building a Control
			Testing a Control
		Deploying a Control
			Creating a Solution
			Building a Solution Project
		Installing a Control
		Using the Control
			Canvas App
			Model-Driven App
		Summary
Part VII: Offline and Integration
	Chapter 23: Working Offline
		What Happens Offline?
		Canvas Formulas That Enable Offline Working
			Saving and Retrieving Local Data
		Making a Canvas App Available Offline
			Setting the Data Source to a Local Collection
			Handling Offline Deletions
				Deleting Records from Local Collections
			Handling Offline Record Updates
				Merging Records
				Using the With Function to Improve Code Readability
			Building the Synchronization Screen
				Disabling Icons and Buttons
			Building the Conflict Resolution Screen
		Making Model-Driven Apps Available Offline
			Setting Up a Mobile Profile
			Running a Model-Driven App Offline
			Configuring Conflict Settings
		Summary
	Chapter 24: Creating Custom Data Connectors
		Overview of Web Services and Custom Connectors
		Overview of Steps
		Understanding How the Web Works
			Making HTTP Web Requests
			Understanding HTTP Responses
		Documenting a Web Service
			Creating a Web Service Description
			Using Postman
			Using Swagger
			Examining an Open API Document
		Creating a Custom Connector
		Using the Custom Connector
		Summary
	Chapter 25: Using Power Automate
		What Is Power Automate?
		What Can We Do with Power Automate?
		Managing and Creating Flows
			Defining Triggers
			Adding Actions
			Accepting Input Values
		Calling Flows
			From Canvas Apps
			From Model-Driven Apps
			Unattended: From a Schedule
		Reviewing Call Histories
		Working with Data
			Connecting to Data
			Filtering Data
		Working with Variables
		Manipulating Data
			Constructing HTML Tables
			Introducing Workflow Definition Language
			Applying Workflow Definition Language
			Using Output Values in Workflow Definition Language Commands
			Referring to Items in Loops
		Approving Actions
		Other Examples
			Managing Files
			Calling SQL Stored Procedures
			Returning Results from a Flow
			Accessing Flow Results from Power Apps
		Summary
Part VIII: Administration
	Chapter 26: Transferring Apps and Data
		Managing Data
			Transferring Dataverse Data with Dataflows
				Importing Data
				Exporting Data
			Managing Dataverse Data with Excel
			Importing Data to SharePoint
			Working with SharePoint Data
		Transferring Data from Canvas Apps
			Exporting Data
			Importing Data
		Transporting Apps with Solutions
			Managing Solutions
			Using the Default Solution
			Viewing Dependencies
			Creating a Solution
			Adding Objects to a Solution
			Controlling Customizations
			Exporting a Solution
			Importing a Solution
			Understanding Solution Layers
			Creating a Patch
		Summary
	Chapter 27: Administering Security
		Securing Data Sources
			Configuring Authentication Settings
			Securing Dataverse Tables
				Introducing Security Roles
				Business Units and Teams
				Understanding Record Ownership
				Creating a Security Role
				Assigning a Security Role to a User
				Testing Our App
				Concluding Notes
			Securing SharePoint Lists
				Implementing Role-Level Access
				Restricting Access to SharePoint Lists
				Restricting Access to Records
			Canvas App Formulas
				Retrieving the Current User
				Filtering Records by the Current User
				Verifying Permissions Within an App
				Disabling Icons and Buttons
				Controlling Record Amendments
				Signing Out Users
		Creating Data Loss Prevention Policies
			Testing a DLP Policy
		Using PowerShell
			Installing Components
			Hiding the Data Source Consent Screens
			Other Useful Commands
			Hiding SharePoint Lists
		Auditing and Analytics
			Auditing App Activity
			Auditing Dataverse Record Activity
			Viewing Analytic Data
		Summary
Appendix A: Sample App Data Structure
Index