AdsPostXis in the In Store Retail Tech Industry

AdsPostX

Functions in Dart provide a powerful way to organize code and encapsulate functionality. In this blog post, we’ll explore different aspects of Dart functions, including positional arguments, one-line functions, optional parameters, and named parameters. Read Parts 1 & 2 of this article: Exploring Dart Fundamentals - Part 1 Exploring Dart Fundamentals - Part 2: Dart Control Flow Statement Done? Let’s get started. 1. Positional Arguments Positional arguments are the most basic type of arguments in Dart functions. Their position in the function call defines them. void add(int x, int y) {
  print(x + y);
} In the function, and are positional arguments. When calling , will be assigned the value and will be assigned , resulting in being printed. add x y add(3, 5) x 3 y 5 8 2. One-Line Function One-line functions provide a concise way to define simple functions in Dart. They are often used for short and straightforward operations. void addsingleLineFunction(int x, int y) => print(x + y); The function is a one-line equivalent of the function. It takes two positional arguments and and prints their sum. addsingleLineFunction add x y Another Method Another method demonstrates another way to define a function in Dart, which implicitly returns a value. addsingleLineFunctionMethod(int x, int y) => x + y; Unlike the previous functions, implicitly returns the sum of and . It does not use the function, making it suitable for returning values directly. addsingleLineFunctionMethod x y print 3. Optional Parameters Optional parameters allow for flexibility in function calls by making certain parameters optional. Positionally Optional addPostional(int x, [int y = 0]) => x + y; The the function takes one required positional argument and one optional positional argument with a default value of . This means you can call or . addPostional x y 0 addPostional(3) addPostional(3, 5) Named Optional calculateArea({double width = 0.0, double height = 0.0}) => width * height; computes the area of a rectangle. It uses named optional parameters and with default values of . This allows for clear and explicit function calls like . calculateArea width height 0.0 calculateArea(width: 10.0, height: 5.0) 5. Named Required Named required parameters ensure that certain arguments are provided during function calls. calculateAreaRequired({required double width , required double height}) => width * height; calculates the area of a rectangle. The parameters and are named and required, meaning you must specify them during the function call. calculateAreaRequired width height Putting It All Together void main() {
  // Function with no parameters
  void greet() {
    print("Hello, Dart!");
  }

  // Function with required parameters
  void greetWithName(String name) {
    print("Hello, $name!");
  }

  // Function with optional parameters
  void greetWithOptional({String name = 'sadanand gadwal'}) {
    print("Hello, $name!");
  }

  // Function with positional parameters
  void greetWithPositional([String name = 'sadanand gadwal']) {
    print("Hello, $name!");
  }

  // Function with return value
  int add(int a, int b) {
    return a + b;
  }

  greet(); // Hello, Dart!
  greetWithName("sadanand gadwal"); // Hello, sadanand gadwal!
  greetWithOptional(name: "sadanand gadwal"); // Hello,sadanand gadwal!
  greetWithOptional(); // Hello, sadanand gadwal!
  greetWithPositional("sadanand gadwal"); // Hello, sadanand gadwal!
  greetWithPositional(); // Hello, sadanand gadwal!
  print(add(3, 5)); // 8
} Conclusion Understanding these different types of parameters and function definitions in Dart is essential for writing clean, readable, and flexible code. They enable you to express complex logic concisely and organized, making your Dart programs more maintainable and efficient. Also published here.

Exploring Dart Fundamentals — Part 3: Dart Functions and Parameter Types 

A Guide to Creating Fun User Polls and Surveys With QuickBlox in Your Flutter App

No one is as excited about opening a can of worms as people in the cybersecurity community, including us. While threat hunting has become quite challenging, partly because of WHOIS data redaction, the . DNS continues to provide clues In this post, we intend to demonstrate how one malicious domain can lead to multiple other dangerous web properties using the , a 9-in-1 domain search and monitoring platform. And with the holiday season coming up, what better way to do that than to use a domain that may have figured in parcel delivery scams or malware delivery? Domain Research Suite (DRS) We started our investigation with the domain deliveryrescheduled-auspost[.]com, which seemingly targeted Australia Post customers. We ended up with 1,871 suspicious domains. Here's a step-by-step guide on how we did the investigation. Check If the Domain Is Malicious The first step is to ensure the suspected domain name has indeed been reported as malicious. We used the for that. The tool’s malware database check detected that deliveryrescheduled-auspost[.]com is indeed dangerous to access. Threat Intelligence Platform (TIP) But even when a suspicious domain hasn’t been reported by malware engines yet, you can follow your gut and proceed to the next step. Retrieve the Domain’s WHOIS Records Now that the domain’s nefarious nature has been confirmed, we can dig deeper by looking at its WHOIS records. For that, we used . WHOIS Search At first glance, we can deduce from the website screenshot that the operators installed the NGINX web server software. However, the corresponding configuration hasn’t been completed yet or the website may have been taken down. Either way, you can scroll down the WHOIS search results until you find the Registrant Contact details. Perform a Reverse WHOIS Lookup The WHOIS records of deliveryrescheduled-auspost[.]com are unredacted, so you can pivot off one data point to retrieve other domains registered using the selected registrant information. In this demonstration, we chose the registrant’s email address. Click the WHOIS record and select Build current Reverse WHOIS report. This action returned 1,712 domain names with the same email address in their current WHOIS records. Note that selecting Build historic Reverse WHOIS report would give you the historical footprint for that email address, which in turn returns an additional 200 or so domains. Do a Reverse DNS Search Aside from WHOIS-connected domains, we can also retrieve a list of digital properties that resolve to the malicious domain’s IP address. To do that, go to and type the domain name into the Obtain connected domains search box. Reverse DNS Search We found 159 domains that shared the IP host of deliveryrescheduled-auspost[.]com. That brings the total number of currently related domains to 1,871. What’s Inside Pandora’s Box? When we performed a bulk malware check on the connected domains, we found that about 17% have been flagged as malicious. That includes other courier-themed domains, such as: auspostdelivery-rescheduled-id101[.]com auspost-redirect-fee[.]com bestsignpostbank[.]com bpost-centrum102[.]com bpost-centrum103[.]com dhlinvoice[.]com evri-courier-deliveryuk[.]com evri-parcel-item[.]com kontopostbank[.]net labanqpostaie[.]com missed-auspostdelivery-id101[.]com parcelreschedule-deliveryauspost[.]com postoffice-depot70[.]com post-servicecenter[.]com redelivery-packageid7287[.]com We discovered other attack vector types. For instance, we found several banking-related domains that have already been used in malicious campaigns. A few of them even posed as part of fraud team efforts, such as: atticas-ebanking[.]com bankid-aterstalla[.]com bankid-uppdatering[.]com bankid-varning[.]com bestsignpostbank[.]com chargeback-commbank[.]com fraudcheck-commbank[.]com fraud-commbank[.]com fraudteam-commbank[.]com kontopostbank[.]net request-cancelcommbank[.]com Several malicious domains appeared to have been created using domain generation algorithms (DGAs), too. These include: 1upl6x[.]com 65hqtk[.]com 73hdhdieij[.]com 93dhj8[.]com 9xe61v[.]com dc183j[.]com fbwqhqwfqxc[.]com fhqwfgqjwqfw[.]com h309-b14r284331[.]su h309-r11b284981[.]su hwqmfqwhsc[.]com sfhasgiasasgh[.]com utabwbazuu[.]com yqywywwyfcscv[.]com — Keep in mind that we uncovered these malicious properties by following the WHOIS and DNS footprints of one domain—deliveryrescheduled-auspost[.]com. By doing so, we found more suspicious domains, many of which have already been weaponized. The threat actors behind these properties may be waiting for the right time to activate some of the dormant domains. You can also perform a similar investigation. Access DRS if you are an existing user or sign up for a free trial plan if you are a first-timer.

Discover a Network of Malicious Domains on Your Own: DIY Guide — Holiday Season Edition

After reading this article, you should be able to create a UI that allows you to use to upload an image to an API endpoint. It will also address the problems that arise when the conventions are not followed. React react-hook-form Prerequisite This article is intended for readers who are already familiar with the following topics. making a API-only application Rails with basic knowledge of React Rails part So, first and foremost, we must create the API-only project by following the steps Rails shown below, type the command to create a new rails app with the default of and as the default database. --api PostgreSQL rails new myprojectname -d postgresql --api Navigate to the project folder and run bundle install Since we are using as our database. Let us configure the database by going to the following path then set the host, username, and password as in the example below PostgreSQL config/database.yml default: &default
  adapter: postgresql
  encoding: unicode
  host: localhost
  username: postgres
  password: myPassword123 Run rails to create the database. db:create Our PostgreSQL database is now complete. It's now time to set up the cors so that other clients can use our API. Let's open the gem file and add the gem as shown below. rack-cors gem "rack-cors" and then run bundle install Then, in , set the origins to your client URL, as shown below. config/initializers/cors.rb Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
    # origins "www.clienturl.com"
    origins 'http://localhost:3006'
    resource "*",
      headers: :any,
      methods: [:get, :post, :put, :patch, :delete, :options, :head]
  end
end since only the local environment will be covered in this article. Let's make the development environment's URL the default. Navigate to and write the code below. config/environments/development.rb Rails.application.routes.default_url_options = {
    host: "http://localhost:3000"
} Let's start with the Post model, which I'll make using a scaffold generator by typing the command below. rails g scaffold Post caption:string then run the migration rails db:migrate Our REST API is now complete, and we can make API calls from the terminal, but we are unable to upload an image. To enable image uploading, we must first install active storage by running the command below. bin/rails active_storage:install rails db:migrate Now, using the path , navigate to the post model and add the image attachment code as shown below. app/models/post.rb class Post < ApplicationRecord
    has_one_attached :image

end You can also add model validation by including the code below. validates :caption, :image, presence: true Then, in the posts controller, permit the image attribute as shown below def post_params
    params.require(:post).permit(:caption, :image)
 end Now, the API returns data in JSON format, as shown below. [
  {
    "id": 14,
    "caption": "Jumping rope time",
    "created_at": "2022-10-31T06:00:32.614Z",
    "updated_at": "2022-10-31T06:00:32.645Z"
  },
  {
    "id": 15,
    "caption": "Today's fashion",
    "created_at": "2022-10-31T06:00:50.969Z",
    "updated_at": "2022-10-31T06:00:50.997Z"
  }
] The data above are attributes returned from our REST API response; we see and , but no image attribute. We need a way to present our data using or to fix this. You can use an active model serializer gem, but I won't go into detail about it in this article. I'm going to create my , which will determine which attributes are returned as JSON by restricting and allowing some of the data, for example, you may choose to hide the attributes while displaying the id, caption, created_at, updated_at serializers representers representers date-time image URL. Because our data is coming from the index action in , the method looks like this: posts_controller.rb def index
  @posts = Post.all
  render json: @posts
end We need to replace the above code with def index
   @posts = Post.all 
   render json: PostRepresenter.new(@posts).as_json
end Since the PostRepresenter class is not defined, as you can see above, we must first open our app folder, then create the representers folder, and finally, create a file called and add the following code to it. posts_representers.rb class PostsRepresenter
    def initialize(posts)
      @posts = posts
    end
  
    def as_json
      posts.map do |post|
        {
          id: post.id,
          caption: post.caption,
          image: post.imageUrl
        }
      end
    end
  
    private
  
    attr_reader :posts
  end The class, which is represented by the code above, has a method called It uses a map block method to repeatedly iterate through all posts and displays the information in JSON format. PostsRepresenter as_json. As you can see, we displayed the image attribute but the is not defined, so let us define it in the file. image: post.imageUrl imageUrl app/model/post.rb def imageUrl   
    Rails.application.routes.url_helpers.url_for(image) if image.attached?
 end As a result, our Post model will look like this: class Post < ApplicationRecord
    has_one_attached :image
    validates :caption, :image, presence: true

    def imageUrl   
      Rails.application.routes.url_helpers.url_for(image) if image.attached?
    end
end Our REST API is now complete, and anyone can consume it using any front-end application such as , , or others, and it returns the JSON response shown below. React Vue [
  {
    "id": 14,
    "caption": "Jumping rope time",
    "image": "http://localhost:3000/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBFdz09IiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--a216f6670f89e8f6d39fbce189af62e3d45633d6/jump%20rope.jpg"
  },
  {
    "id": 15,
    "caption": "Today's fashion",
    "image": "http://localhost:3000/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBGQT09IiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--be43dde8cfaa13e097b95e936e1a9cfd817f21e3/fashion.png"
  },
  {
    "id": 25,
    "caption": "The sport I like",
    "imageUrl": "http://localhost:3000/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBIZz09IiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--31fcdcf03292d53f4d9df25c1a46dc12844992f5/jump%20rope.jpg"
  }
] React.js part This section will go over the Axios for making API calls, as well as the react-hook-form and the context API. Now, run the following command to create the react app. npx create-react-app imageuploader

cd imageuploader Since the rails API is running on port 3000. Let us change the front-end port to 3006 by creating a file and pasting the code below. .env PORT=3006 then, by entering the following commands, we'll install the dependencies we'll need for this project. npm install axios
npm install react-hook-form Since and are currently empty, we must first create them before importing them into . We are aware that we must use the context API to manage states. To use it throughout all of our components, we will create the context . After that, we will apply this context to the returned jsx. Any app component will be able to access the state. AddPost.js DisplayPost.js App.js PostContext import { createContext, useState } from "react";
import AddPost from "./components/AddPost";
import DisplayPost from "./components/DisplayPost";

export const PostContext = createContext(null); // Defining the context

function App() {
  const [post, setPost] = useState(PostContext) // Defining the states using context
  return (
    <PostContext.Provider value={{post, setPost}}> // Wrapping the app with the context API
      <div className="container">
       <AddPost />
       <DisplayPost />
      </div>
    </PostContext.Provider>
  );
}

export default App; We must now focus on the AddPost.js component. Let us create a form that, when submitted, will send a POST request to the API and store the response in the state. To use the react-hook-form, we must first import the useForm hook. This hook has a method that receives a callback sendDataToApi that receives form inputs. To upload an image, we must use object and append the form inputs. It is common practice to use the string containing the rails . If the name of your model is and it has an attribute like , you could use as the key to the Formdata; otherwise, the rails backend app will throw an error saying . When the post request is successful, you must save the response data's state to the context API. handleSubmit FormData() “modelname[attribute]” Post image "post[image]" Unpermitted parameter::image import React, { useContext, useState } from 'react'
import axios from 'axios';
import { useForm } from 'react-hook-form';
import { PostContext } from '../App';

const AddPost = () => {
  const { register, handleSubmit, reset } = useForm(); // 
  const {post, setPost} = useContext(PostContext);

  const sendDataToApi = (data) => {
    const formData = new FormData()
    const post = { ...data, image: data.image[0] }
    formData.append('post[caption]', post.caption)
    formData.append('post[image]', post.image)
    console.log(formData)
    axios.post('http://localhost:3000/posts', formData, {
      headers: { 'Content-Type': 'multipart/form-data' },
      withCredentials: true,
    })
    .then((response) => {
      if(response.data.status === 'created') {
        setPost(response.data.post)
      }
    })
    reset()
  };

 return (
    <div>
      <h1>Wall of fame</h1>
      
      <form className="form" onSubmit={handleSubmit(sendDataToApi)}>
        <div className="form-floating mb-2 col-10">
          <input type="file"  name="image"  {...register('image')} accept="image/*" />
          <label htmlFor="floatingInputImage">Image</label>
        </div>
        <div className="form-floating mb-2 col-10">
          <input type="file"  name="caption"  {...register('caption')} accept="image/*" />
          <label htmlFor="floatingInput">Caption</label>
        </div>
                  
        <div className="form-floating mb-3 col-10">
           <button type="submit" className="btn btn-primary ">Add Car</button>
        </div>
      </form>
    </div>
  )
}

export default AddPost Let us go to DisplayPost.js, here on page refresh hook will fetch all posts using the get request and save them to the context API using method. See the code below it explain it well. useEffect setPost import React, { useContext, useEffect } from 'react'
import axios from 'axios'
import { AppContext } from '../App'
import Loading from './Loading';


const DisplayPost = () => {
    const {post, setPost} = useContext(AppContext);
    
    useEffect(() => {
        axios.get('http://localhost:3000/posts')
        .then((response) => {
        setPost(response.data)
        })
    }, [setPost])

  
    
  return (
    <div className='container border border-info'>
        <div className="row">
            {
                Array.from(post).map((data) => {
                    return (
                        <div className="col-3"  key = {data.id}>
                            <div className="card">
                                <img className="card-img-top" src={data.image} alt="url for foto" />
                                <div className="card-body">
                                  <p className="card-text">{data.caption}</p>
                                </div>
                            </div>
                        </div>
                    )
                })
            }
        </div>
    </div>
  )
}

export default DisplayPost Now that the front end is complete, you can upload the image to the Ruby on Rails API backend locally. To make it work in production, we must store the photos in services such as which I will discuss in the following article. AWS S3 buckets, Thank you for your time.

How to Upload an Image From React to the Rails API Using React-hook-form and Context API

How to Handle Asynchronous Data Requests Using Redux Toolkit

What you’ll be building. See live and Git Repo . demo Here Introduction Do you want to advance in your app development career? Then it's time to complete this LinkedIn Clone Project. We will create a LinkedIn Clone using ReactNative, which will vastly improve your understanding of this cross-platform framework. This tutorial was put together with the help of , , and . We will be creating project with your JavaScript skills, as shown in the images above. If you want to add this project to your portfolio, then jump on the keyboard with me and we'll figure it out. ReactNative Firebase CometChat Prerequisite To digest this tutorial, you should already have ground knowledge of ReactNative, the rest of the stacks can easily be understood with no hassle. Listed below are the packages used for developing this application. - - - - - - ReactNative Firebase - CometChat - Formik Yup ReactNative Media Query Expo NodeJs Installing The Project Dependencies First, Download and Install NodeJs on your machine, visit their and complete the installation if you haven’t already. Next, you need to have the Expo-CLI installed on your computer using the command below. You can visit their doc page using this . website link # Install Expo-CLI npm install --global expo-cli Afterward, open the terminal and create a new expo project with the name linkedin-clone and choose the blank template when prompted. Use the example below to do this. #Create a new expo project and navigate to the directory expo init linkedin-clone cd linkedin-clone #Start the newly created expo project expo start Running the above commands on the terminal will create a new react-native project and start it up on the browser. Now you will have the option of launching the IOS, Android, or the Web interface by simply selecting the one that you want. To spin up the development server on IOS or Android you will need a simulator for that, use the instruction found here to use an IOS or Android simulator, otherwise, use the web interface and follow up the tutorial. Awesome, now let's install these essential dependencies for our project using the instruction below. The default package manager for the expo is yarn, see the codes below. # Install the native react navigation libraries yarn add @react-navigation/native yarn add @react-navigation/native-stack #Installing dependencies into an Expo managed project expo install react-native-screens react-native-safe-area-context # Install Yup and Formik for validating our forms yarn add formik yup Amazing, now let’s set up Firebase for this project. Setting Up Firebase First, run the command below on your expo project terminal. Use the code below to properly install it. #Install firebase with the command expo install firebase Good, let's set up the firebase console for this project including the services we will be using. We will proceed by signing up for a firebase account if you don’t have one already. Afterward, head to Firebase and create a new project named linkedin-clone, activate the email and password authentication service, details are spelled out below. Firebase provides support for authentication using different providers. For example, Social Auth, phone numbers, as well as the standard email and password method. Since we’ll be using the email and password authentication method in this tutorial, we need to enable this method for the project we created in Firebase, as it is by default disabled. Under the authentication tab for your project, click the sign-in method and you should see a list of providers currently supported by Firebase. Epic, let's activate the Firestore service which we will be used for storing all the posts coming from our linkedin-clone application. To activate the Firestore service, navigate to the Firestore tab on the sidebar as seen in the images below and click on “create database”. Next, go to the Firestore rules and make the changes as seen in the images below. Next, we want to use the timestamp as an index for ordering our posts, to do so, we have to create an index for it. Follow the process as seen in the images below. Click on the single field tab and add an exception as seen in the image below. Enter posts as the collection ID and timestamp as the field. Click next, and enable the scopes as seen in the images below. If you have done the above steps correctly, you should have the same result as seen in the image below. Once everything is completed, the loading indicators on the exception blocks should disappear and should now look like this. Nice, you have set up all that we will need for the Firestore services, now lets generate the Firebase SDK configuration keys. You need to go and register your application under your Firebase project. On the project’s overview page, select the add app option and pick web as the platform. Once you finish up the SDK config registration, navigate back to the project overview page as seen in the image below. Now you click on the project settings to copy your SDK configuration setups. The config keys seen in the image above must be copied to a separate file which we will later use in the course of this project. Create a file in the root of this project called firebase.js and paste the following codes and save. If you followed all that correctly, you are awesome. Now we will do a similar thing for CometChat next. Setting CometChat Head to and signup if you don’t have an account with them. Next, log in and you will be presented with the screen below. CometChat Click on the Add New App button to create a new app, you will be presented with a modal where you can enter the app details to be created. An example is seen in the image below. After the app creation, you will be navigated to your app dashboard which should look like this. You will also need to copy those keys to a separate file in the manner below. Simply create a file called CONSTANTS.js in the root of the project and paste the code below. Now list this file in the gitIgnore file which is also at the root of this project, this will make sure it won’t be published online. export const CONSTANTS = { APP_ID: 'xxx-xxx-xxx', REGION: 'us', Auth_Key: 'xxx-xxx-xxx-xxx-xxx-xxx-xxx-xxx', } Fantastic, that will be enough for the setups, let’s start integrating them all into our application. The Components Directory We have several directories in this project, let's start with the components folder. Create a folder called components within the root of this project. Let's start with the Header component. The Header Component Using the power of react-native-media-query, you will be able to craft out the header component as seen in the image above. Cool, lets add the next component to the components directory. The BottomTabs Component This sticky component is seen at the bottom of the HomeScreen. When you click on the post button, you will be navigated to the . Create a component called and paste the codes below into it. See the code snippet below. AddPostScreen BottomTabs.js Lastly, lets include the card component for this project. The Card Component This is a well-crafted card with many parts to it, it's better to see the code yourself. Create a component called in the components directory and paste the codes below into it. Card.js Awesome, we are just done with the components directory, its time we create the screens. The Screens Directory The screens can be likened to pages on a website, each screen represents a page and you can navigate from screen to screen using the ReactNative navigator package. Let's proceed with the SignupScreen. The Signup Screen This screen is responsible for creating new users. It interfaces between Firebase authentication and CometChat’s. With this screen, you will be able to signup new users to Firebase, and also to CometChat all at once. See the codes below. The Login Screen This screen authenticates already existing users in our platform. When you log in with your correct details, you will be authenticated both with Firebase and CometChat. If you have supplied the correct data you will be let into the system, otherwise, you will be kicked out. Check out the codes below. The Home Screen The Home Screen comprises three components. The Header, Card, and BottomTabs components. This screen dynamically renders the Card component in synchronization with the posts in Firestore. See the code snippet below. The AddPostScreen This screen is responsible for creating new posts. Using Formik and Yup, we collect data from a form and save it to the Firestore database. Here are the codes exhibiting this behavior. The ChatsListScreen The ChatList Screen is responsible for listing all users registered on our platform. Using the CometChat SDK we will retrieve the list of users registered with us. This is how the code looks like. The ChatScreen Lastly, we have the chat screen where users engage in a one-on-one chat. Below is the code for it. Setting Up The Router Now that we have the project all coded, let's set up the navigation routers and guards, create and paste the following codes as directed below. The Navigation fileThis categorizes the screens into two groups, the ones requiring authentication and the others not requiring authentication. Create a new file in the root of the project name and paste the codes below inside of it. “navigation.js” The AuthNavigation file This file logically presents screens to you based on the authState of the firebase authentication service. To proceed, create another file in the root of the project name and paste the codes below inside of it. “AuthNavigation.js” The App file Lastly, replace the codes in the App.js file with the following codes. Congratulations, you just crushed this app, you just need to bring in some of the static images. Download the following images and put them in your assets directory. https://raw.githubusercontent.com/Daltonic/linkedIn-clone/main/assets/logo.png https://raw.githubusercontent.com/Daltonic/linkedIn-clone/main/assets/avatar.jpg https://raw.githubusercontent.com/Daltonic/linkedIn-clone/main/assets/default-avatar.jpg Awesome, you can spin up your server using the code below on your terminal if you have not done that already. # Start your ReactNative local server on the web view yarn web Conclusion Nothing is impossible here; you can crush a chat app with , , and . You've seen how to implement it step by step; now it's time to crush other chat apps on your own. I also have other tutorials that will show you how to create a private or public group chat. ReactNative Firebase CometChat I'm looking forward to seeing your stunning creations. First published here

Build a LinkedIn Chat Clone with React Native and Firebase

A Great Way To Create A Brilliant GraphQL-Powered Blog

My first approach to React was enough to fall in love with this framework: it's easy to work with, has a simple syntax, and it's so fast that you can build a simple application in less than a day. Using React on your app allows you to update the information you display on the browser without having to reload the whole page, as it works with a . virtual DOM One of the best characteristics React has is the state. It is a way to store your app's component data, keep track of the changes, and then render them faster than using only JavaScript. However, once your app starts growing, managing tens of states in multiple containers starts getting difficult and becomes inefficient. That's where Redux comes into play. is an amazing tool that allows you to keep all your application's state in one centralized . Redux store Each component's state will now be handled by your Redux store and it will be available for the rest of your application's components without having to send it as from parent to child. What's the advantage? props That way it's so easy to work with that centralized store instead of having to navigate through all your containers trying to find where you were passing the props you need when you want to add or change them. Moreover, using Redux ensures you follow a specific path to modify the state, making it almost impossible to change it directly ( ). All this while being incredibly easy to set up. something you already know you shouldn't do Before you start Got hooked? Ok, let's add Redux to your application. You will need a running app that uses React. I won't talk you through that process in this article, but you can check the if you need help. React documentation Just in case, I will remind you of some key concepts I will be talking about in this article: : the object that contains the state of the application. Store s: objects that describe you want to change on the Redux store's state. Action what : functions that handle actions and tell the Redux store to modify the state. Reducers how The above it's a great graphic representation of how Redux works. With that in mind, let's get to work! image Data Flow Installing and Setting Up Redux To on your app, you will need to use . On your terminal, cd into your project's directory and type . This will not only install Redux but also add another package (react-redux) to connect your app with the Redux store. install Redux Node npm install redux react-redux Since you are working on an already functional React app, you will only need to add and change a few things on your components to connect them to the new store that will handle the state. I will explain the process in a somewhat reverse way: you will create the store, link the reducers, then build them, and finally, you will create the actions file. The above process will need you to import files and functions before creating them. I believe this way is better because you get to see the big picture first and then work with the details, making it less likely to miss a step. This is the file where rendering to the DOM. In there, you will need to: and also . With those functions you will create the where your app's state will live, and then make it available to all the components using the . Your index.js file should look something like this: 1. Edit to your index.js import { createStore } from 'react-redux' import { Provider } from 'Redux' Redux store Provider React ; ReactDOM ; ; { createStore } ; { Provider } ; App ; rootReducer ; store = createStore(rootReducer);

ReactDOM.render( <Provider store={store}><App /></Provider> import from 'react' import from 'react-dom' import './index.css' import from 'redux' import from 'react-redux' import from './App' import from './store/reducers/rootReducer' const < > React.StrictMode ,
  document.getElementById('root'),
); </ > React.StrictMode Notice how you need to create the store using that takes a reducer as an argument (you will create the reducer next). Also, remember to enclose your App component by the component you just imported and passing the as a prop. const store = createStore(rootReducer) Provider store On the above example you already are importing a called from the corresponding location and passing it as an argument to . 2. Create the rootReducer file reducer rootReducer createStore() rootReducer ; store = createStore(rootReducer); import from './store/reducers/rootReducer' const Depending on the size of your application you can have one or more reducers to specify how the application's state changes. That is perfect, as long as you connect all of them using the rootReducer. Now let's create that file in the proper location and start working with it. First, you need to . This will allow you to connect all the reducers your application has. In this case I'm using only two, but you can have as many as needed (remember to import them, too). import { combineReducers } from 'redux' { combineReducers } ; authReducer ; postReducer ; rootReducer = combineReducers({ : authReducer, : postReducer,
}); rootReducer; import from 'redux' import from './authReducer' import from './postReducer' const auth posts export default The above code shows how to import all the reducers your app has (remember we are going backward, but you can create them before adding them to the rootReducer, it's your choice). As you can see, takes an object as an argument (if you have more than one reducer). The object's key will be the name of the state (and you will use this exact name in your components), and the object's value will specify which reducer to use to change the Redux state. combineReducers() There are other ways to set up the rootReducer and to use this method. You can check more details on the Redux documentation and . here here 3. Create the reducers Let's say you are building a collective blog and you want to keep track of the posts your users create and update them on the main page. You will need a reducer to track the state and render it when it changes. A reducer is just a function that explains to modify your state, depending on the given action (more on that later). how A good practice is to keep all your reducers (including the rootReducer) in a Reducers folder Now, on your reducer file, you will need: 1) an that stores a default version of your state (your app will use it the first time), and 2) the . initialState reducer function You should pay attention to the name of your reducer and make sure it is the same you included on the rootReducer file. initState = { : [],
}; postReducer = { (action.type === ) { post = { : action.id, : action.title, : action.category,
    }; nextPosts = { ...state.posts, post }; { ...state, : nextPosts }; } state;
} postReducer; const posts const ( ) => state = initState, action if 'CREATE_POST' const id title category const // state.posts is refering to the key of the rootReducer return posts // adds the new object to the current state return export default As you can see, the reducer function takes and as arguments. It then checks all the actions to find the match and make the adjustments to the state. initState action In the example above, I am using the action to create a new post and then add it to the current that I previously referred to on the rootReducer. After that, I return a new object with the final state and the modified . 'CREATE_POST' state.posts posts.state 4. Actions and actions' creators Now, where does that come from? It is a type of . Actions are the way you communicate with the store. It's the only information that will be sent to it. 'CREATE_POST' action You can start by creating an folder to store your action files. To follow the example above, that folder would contain a file that looks like this: actions postActions.js { { : ,
    title,
    content,
  };
} { { : ,
    id,
  };
} // This is the action creator export ( ) function addPost title, content // This is the action return type 'ADD_POST' // This is the action creator export ( ) function deletePost id // This is the action return type 'DELETE_POST' The code above shows a list of or functions that enclose and return objects called . This function is the one you will call in the component when you want to update the state. action creators actions You can add as many actions and action creators as you need. I will just include two to and posts. Inside each action, you need to return the action's to indicate what action to choose when sending the information to the store. create delete type Each action will take different arguments, depending on the necessary information to change the state. Those arguments are also returned. For example, takes two arguments: and to create a new post. You need to return them inside each action so that they are accessible to change the state. addPost() title content 5. Connect your component to the Redux store Ok, remember we are going backward. This is the final step. Up until now, you haven't changed anything on your app, just added more files. Now will be the time to get rid of the state you have on each component and instead connect them to the store. To do this, we will import a function called into our component's file. { connect } from 'react-redux' React ; PostSummary ; { connect } ; PostList = { { posts } = props; ( <PostSummary post={post} key={post.id} />
      ))}
    </div> import from 'react' import from './PostSummary' import from 'react-redux' const => props const return {posts && posts.map(post => ( < = > div className "post-list section" )
};

const mapStateToProps = state => ({
  posts: state.posts,
});

export default connect(mapStateToProps)(PostList); This is a usual component that uses Redux to store the state. Don't worry if you don't understand everything, I will dissect it in a few. Following the blog example, this would be the component that renders the list of posts. It doesn't have a state (we don't need it) but we are passing some . props I am using destructuring to create the constant from the props.  That constat it's an array with a list of all the posts taken directly from the Redux store. posts How is that happening? The code is including a : mapStateToProps() mapStateToProps = ({ : state.posts,
}); const => state posts This function takes the application's state as a parameter and then returns an object with the piece of state that you need, and passes it to the component in the form of props. After setting that up, you need to: Export the component while calling . connect() Pass the recently created as an argument. mapStateToProps() Add the component's name between parenthesis. You can read more about how works, . connect() here connect(mapStateToProps)(PostList); export default Then, the PostList component can connect to the Redux store, grab the posts from the state, and then render it or do whatever we want with it. But, how do we the state? In a very similar way, we can add another function that will one of our action creators and modify the state without changing something we don't want to. change dispatch mapDispatchToProps = ({ : {
    dispatch(addPost(post.title, post.content));
  },
}); connect(mapStateToProps, mapDispatchToProps)(PostList); const => dispatch addPost => post export default Don't be intimidated by the code above. I will explain line by line and you can also check this . thorough explanation On the first line, takes as the first argument. On line two, it returns a new function with as the argument. mapDispatchToProps() dispatch() addPost() post Finally, on the third line, the function calls inside, and passes the action creator as the argument. If you remember, takes the post's title and content as arguments, so we need to pass them, too as and . dispatch() addPost() addPost() post.title post.content It might be confusing to see two but please keep in mind that they are not the same. You could easily change the first name to something entirely different with no errors, but you can't do the same with the second one, since it's referring to the action creator. addPost() addPost() That's why you should also remember to import the action creator using in the beginning of your file. import { addPost } from '../actions/' With we are not only connecting to the Redux store but also making use of the previously created actions and reducers to change the store's state. mapDispatchToProps() You can return multiple functions inside , depending on what you want your component to do and how you want it to interact with your application's state. mapDispatchToProps() As you will see after migrating all the component states to one centralized store, your application's flow will be more organized and you will be able to access the state from anywhere, making your website more flexible. A quick reminder: not all component states are useless when working with Redux, and when you want your Redux store to handle some parts of the state, and your components another part. there will be cases And that's it! You should have a fully functional React - Redux application! : Overview Install and . redux react-redux Create the and enclose your with the . store app component Provider Create your with connect(). rootReducer Create the individual reducers (if necessary). Build your . action creators Create and functions on your components. mapStateToProps() mapDispatchToProps() Export your component with connect(). Delete your previous component state. I would love to hear from you! Please send a message with your feedback on this article to any of my social media / / Twitter LinkedIn Github

ADSPOSTX

adspostx.com

-- employees

Since n.d.

COMPANY RANKING

ADSPOSTX

EVERGREEN INDEX #761

Representing this company? Click here to claim and customize this page!

AdsPostX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

ADSPOSTX

adspostx.com

-- employees

Since n.d.

COMPANY RANKING

ADSPOSTX

EVERGREEN INDEX #761

RELATED COMPANIESRANK

STORIES ABOUT ADSPOSTX

Representing this company? Click here to claim and customize this page!

AdsPostX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!