Merge branch 'release/v28.1.1.OS'

Vagrantfile

@@ -3,8 +3,6 @@ Vagrant.configure("2") do |config|
     config.vm.box_version = "1.0.0"
     config.vm.network "private_network", ip: "192.168.10.12"
     config.vm.synced_folder ".", "/vagrant", type: "nfs"
-    config.vm.synced_folder "./deployment/vagrant/sites-available", "/etc/nginx/sites-enabled", type: "nfs"
-    config.vm.synced_folder "./deployment/vagrant/ssl", "/etc/nginx/ssl", type: "nfs"
 
     config.vm.provider "virtualbox" do |vb|
       vb.memory = "1024"
@@ -13,9 +11,17 @@ Vagrant.configure("2") do |config|
     end
 
     config.vm.provision "shell", inline: <<-SHELL
+    	sudo rm /etc/nginx/ssl/icehrm.*
+        sudo ln -s /vagrant/deployment/vagrant/ssl/icehrm.crt /etc/nginx/ssl/icehrm.crt
+        sudo ln -s /vagrant/deployment/vagrant/ssl/icehrm.key /etc/nginx/ssl/icehrm.key
+
+        sudo rm /etc/nginx/sites-enabled/default
+        sudo ln -s /vagrant/deployment/vagrant/sites-available/default /etc/nginx/sites-enabled/default
+
         sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
-        systemctl restart sshd.service
+
         sudo service nginx restart
+        sudo chmod 755 -R /var/log
     SHELL
 
     config.vm.hostname = "icehrm.os"

app/rest.php

@@ -1,3 +1,7 @@
 <?php
 include ('config.php');
+if (isset($_REQUEST['method']) && isset($_REQUEST['url'])) {
+    include (APP_BASE_PATH.'api.php');
+} else {
     include (APP_BASE_PATH.'rest.php');
+}

core/api.php

@@ -0,0 +1,41 @@
+<?php
+define('CLIENT_PATH',dirname(__FILE__));
+include ("config.base.php");
+include ("include.common.php");
+include("server.includes.inc.php");
+
+if(\Classes\SettingsManager::getInstance()->getSetting('Api: REST Api Enabled') == '1') {
+
+    \Utils\LogManager::getInstance()->info("Request: " . $_REQUEST);
+
+    if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
+        http_response_code(200);
+        exit();
+    }
+
+    define('REST_API_PATH', '/');
+
+    $echoRoute = \Classes\Macaw::get(REST_API_PATH . 'echo', function () {
+        echo "Echo " . rand();
+    });
+
+    \Utils\LogManager::getInstance()->debug('Api registered URI: '.$echoRoute);
+
+    $moduleManagers = \Classes\BaseService::getInstance()->getModuleManagers();
+
+    foreach ($moduleManagers as $moduleManagerObj) {
+
+        $moduleManagerObj->setupRestEndPoints();
+    }
+    $method = $_SERVER['REQUEST_METHOD'];
+    if (strtoupper($method) === 'GET') {
+        \Classes\IceRoute::dispatch($_GET['url'], $method);
+    } else {
+        $method = strtoupper($_REQUEST['method']);
+        \Classes\IceRoute::dispatch($_REQUEST['url'], $method);
+    }
+
+
+}else{
+    echo "REST Api is not enabled. Please set 'Api: REST Api Enabled' setting to true";
+}

core/src/Classes/FileService.php

@@ -94,6 +94,8 @@ class FileService
                 $s3FileSys = new S3FileSystem($uploadFilesToS3Key, $uploadFilesToS3Secret);
                 $result = $s3FileSys->putObject($s3Bucket, $uploadname, $localFile, 'authenticated-read');
 
+                $file->size = filesize($localFile);
+
                 unlink("/tmp/".$file->filename);
                 unlink("/tmp/".$file->filename."_orig");
 
@@ -101,7 +103,6 @@ class FileService
 
                 $file->employee = $profileImage->employee;
                 $file->file_group = 'profile_image_small';
-                $file->size = filesize(CLIENT_BASE_PATH.'data/'.$file->filename);
                 $file->size_text = $this->getReadableSize($file->size);
 
                 if (!empty($result)) {
@@ -293,8 +294,7 @@ class FileService
             if ($file->employee == $profileId) {
                 $ok = $file->Delete();
                 if ($ok) {
-                    LogManager::getInstance()->info("Delete File:".CLIENT_BASE_PATH.$file->filename);
+                    $this->deleteFileFromDisk($file);
-                    unlink(CLIENT_BASE_PATH.'data/'.$file->filename);
                 } else {
                     return false;
                 }
@@ -306,8 +306,7 @@ class FileService
             if ($file->employee == $profileId) {
                 $ok = $file->Delete();
                 if ($ok) {
-                    LogManager::getInstance()->info("Delete File:".CLIENT_BASE_PATH.$file->filename);
+                    $this->deleteFileFromDisk($file);
-                    unlink(CLIENT_BASE_PATH.'data/'.$file->filename);
                 } else {
                     return false;
                 }
@@ -317,6 +316,30 @@ class FileService
         return true;
     }
 
+    public function deleteFileFromDisk($file)
+    {
+        $uploadFilesToS3 = SettingsManager::getInstance()->getSetting("Files: Upload Files to S3");
+
+        if ($uploadFilesToS3 == "1") {
+            $uploadFilesToS3Key = SettingsManager::getInstance()->getSetting(
+                "Files: Amazon S3 Key for File Upload"
+            );
+            $uploadFilesToS3Secret = SettingsManager::getInstance()->getSetting(
+                "Files: Amazone S3 Secret for File Upload"
+            );
+            $s3Bucket = SettingsManager::getInstance()->getSetting("Files: S3 Bucket");
+
+            $uploadname = CLIENT_NAME."/".$file->filename;
+            LogManager::getInstance()->info("Delete from S3:".$uploadname);
+
+            $s3FileSys = new S3FileSystem($uploadFilesToS3Key, $uploadFilesToS3Secret);
+            $s3FileSys->deleteObject($s3Bucket, $uploadname);
+        } else {
+            LogManager::getInstance()->info("Delete:".CLIENT_BASE_PATH.'data/'.$file->filename);
+            unlink(CLIENT_BASE_PATH.'data/'.$file->filename);
+        }
+    }
+
     public function deleteFileByField($value, $field)
     {
         LogManager::getInstance()->info("Delete file by field: $field / value: $value");

core/src/Classes/IceRoute.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace Classes;
+
+/**
+ * @method static IceRoute get(string $route, Callable $callback)
+ * @method static IceRoute post(string $route, Callable $callback)
+ * @method static IceRoute put(string $route, Callable $callback)
+ * @method static IceRoute delete(string $route, Callable $callback)
+ * @method static IceRoute options(string $route, Callable $callback)
+ * @method static IceRoute head(string $route, Callable $callback)
+ */
+class IceRoute
+{
+
+    public static $halts = false;
+
+    public static $routes = array();
+
+    public static $methods = array();
+
+    public static $callbacks = array();
+
+    public static $patterns = array(
+        ':any' => '[^/]+',
+        ':num' => '[0-9]+',
+        ':all' => '.*'
+    );
+
+    public static $error_callback;
+
+    /**
+     * Defines a route w/ callback and method
+     */
+    public static function __callstatic($method, $params)
+    {
+
+        $uri = $params[0][0];
+        $callback = $params[0][1];
+
+        array_push(self::$routes, $uri);
+        array_push(self::$methods, strtoupper($method));
+        array_push(self::$callbacks, $callback);
+
+        return $uri;
+    }
+
+    /**
+     * Defines callback if route is not found
+    */
+    public static function error($callback)
+    {
+        self::$error_callback = $callback;
+    }
+
+    public static function haltOnMatch($flag = true)
+    {
+        self::$halts = $flag;
+    }
+
+    /**
+     * Runs the callback for the given request
+     */
+    public static function dispatch($uri, $method)
+    {
+
+        $searches = array_keys(static::$patterns);
+        $replaces = array_values(static::$patterns);
+
+        $found_route = false;
+
+        self::$routes = str_replace('//', '/', self::$routes);
+
+        // check if route is defined without regex
+        if (in_array($uri, self::$routes)) {
+            $route_pos = array_keys(self::$routes, $uri);
+            foreach ($route_pos as $route) {
+                //using an ANY option to match both GET and POST requests
+                if (self::$methods[$route] == $method || self::$methods[$route] == 'ANY') {
+                    $found_route = true;
+
+                    //if route is not an object
+                    if (!is_object(self::$callbacks[$route])) {
+                        //grab all parts based on a / separator
+                        $parts = explode('/', self::$callbacks[$route]);
+
+                        //collect the last index of the array
+                        $last = end($parts);
+
+                        //grab the controller name and method call
+                        $segments = explode('@', $last);
+
+                        //instanitate controller
+                        $controller = new $segments[0]();
+
+                        //call method
+                        $controller->$segments[1]();
+
+                        if (self::$halts) {
+                            return;
+                        }
+                    } else {
+                        //call closure
+                        call_user_func(self::$callbacks[$route]);
+
+                        if (self::$halts) {
+                            return;
+                        }
+                    }
+                }
+            }
+        } else {
+            // check if defined with regex
+            $pos = 0;
+            foreach (self::$routes as $route) {
+                if (strpos($route, ':') !== false) {
+                    $route = str_replace($searches, $replaces, $route);
+                }
+
+                if (preg_match('#^' . $route . '$#', $uri, $matched)) {
+                    if (self::$methods[$pos] == $method) {
+                        $found_route = true;
+
+                        array_shift($matched); //remove $matched[0] as [1] is the first parameter.
+
+
+                        if (!is_object(self::$callbacks[$pos])) {
+                            //grab all parts based on a / separator
+                            $parts = explode('/', self::$callbacks[$pos]);
+
+                            //collect the last index of the array
+                            $last = end($parts);
+
+                            //grab the controller name and method call
+                            $segments = explode('@', $last);
+
+                            //instanitate controller
+                            $controller = new $segments[0]();
+
+                            //fix multi parameters
+                            if (!method_exists($controller, $segments[1])) {
+                                echo "controller and action not found";
+                            } else {
+                                call_user_func_array(array($controller, $segments[1]), $matched);
+                            }
+
+                            //call method and pass any extra parameters to the method
+                            // $controller->$segments[1](implode(",", $matched));
+
+                            if (self::$halts) {
+                                return;
+                            }
+                        } else {
+                            call_user_func_array(self::$callbacks[$pos], $matched);
+
+                            if (self::$halts) {
+                                return;
+                            }
+                        }
+                    }
+                }
+                $pos++;
+            }
+        }
+
+        // run the error callback if the route was not found
+        if ($found_route == false) {
+            if (!self::$error_callback) {
+                self::$error_callback = function () {
+                    header($_SERVER['SERVER_PROTOCOL']." 404 Not Found");
+                    echo '404';
+                };
+            }
+            call_user_func(self::$error_callback);
+        }
+    }
+}

core/src/Classes/Macaw.php

@@ -42,6 +42,8 @@ class Macaw
         array_push(self::$methods, strtoupper($method));
         array_push(self::$callbacks, $callback);
 
+        call_user_func('\Classes\IceRoute::'.$method, $params);
+
         return $uri;
     }
 

core/src/Classes/RestEndPoint.php

@@ -420,6 +420,8 @@ class RestEndPoint
             if (preg_match('/Bearer\s(\S+)/', $headers, $matches)) {
                 $token = $matches[1];
             }
+        } else {
+            $token = $_GET['token'];
         }
 
         if (strlen($token) > 32) {

core/src/Employees/User/Api/EmployeesActionManager.php

@@ -147,6 +147,10 @@ class EmployeesActionManager extends SubActionManager
             return new IceResponse(IceResponse::ERROR, "Error occurred while changing password");
         }
 
+        if (!PasswordManager::verifyPassword($req->current, $user->password)) {
+            return new IceResponse(IceResponse::ERROR, "Current password is incorrect");
+        }
+
         $passwordStrengthResponse = PasswordManager::isQualifiedPassword($req->pwd);
         if ($passwordStrengthResponse->getStatus() === IceResponse::ERROR) {
             return $passwordStrengthResponse;
@@ -158,6 +162,6 @@ class EmployeesActionManager extends SubActionManager
             return new IceResponse(IceResponse::ERROR, $user->ErrorMsg());
         }
 
-        return new IceResponse(IceResponse::SUCCESS, $user);
+        return new IceResponse(IceResponse::SUCCESS, []);
     }
 }

web/admin/src/documents/lib.js

@@ -154,7 +154,7 @@ class EmployeeDocumentAdapter extends AdapterBase {
 
   getFilters() {
     return [
-      ['employee', { label: 'Employee', type: 'select2', 'remote-source': ['Employee', 'id', 'first_name+last_name'] }],
+      ['employee', { label: 'Employee', type: 'select2', 'remote-source': ['Employee', 'id', 'first_name+last_name', 'getActiveSubordinateEmployees'] }],
 
     ];
   }

web/api/AdapterBase.js

@@ -55,7 +55,7 @@ class AdapterBase extends ModuleBase {
   }
 
   setupApiClient(token) {
-    this.apiClient = new IceApiClient(this.apiUrl, token);
+    this.apiClient = new IceApiClient(this.apiUrl, token, window.CLIENT_BASE_URL, true);
   }
 
   setApiUrl(apiUrl) {

web/api/CustomAction.js

@@ -0,0 +1,26 @@
+const axios = require('axios');
+
+class CustomAction {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+
+  execute(subAction, module, request, isPost) {
+    if (!isPost) {
+      return axios.get(
+        this.adapter.moduleRelativeURL,
+        {
+          params: {
+            t: this.adapter.table, a: 'ca', sa: subAction, mod: module, req: request,
+          },
+        },
+      );
+    }
+
+    return axios.post(this.moduleRelativeURL, {
+      t: this.adapter.table, a: 'ca', sa: subAction, mod: module, req: request,
+    });
+  }
+}
+
+export default CustomAction;

web/api/IceApiClient.js

@@ -1,12 +1,19 @@
 const axios = require('axios');
 
 class IceApiClient {
-  constructor(baseUrl, token) {
+  constructor(baseUrl, token, clientBaseUrl, legacyApiWrapper = true) {
     this.baseUrl = baseUrl;
     this.token = token;
+    this.clientBaseUrl = clientBaseUrl;
+    this.legacyApiWrapper = legacyApiWrapper;
   }
 
   get(endpoint) {
+    if (this.legacyApiWrapper) {
+      const url = `${this.clientBaseUrl}rest.php?token=${this.token}&method=get&url=/${endpoint}`;
+      return axios.get(url);
+    }
+
     return axios.get(this.baseUrl + endpoint, {
       headers: {
         Authorization: `Bearer ${this.token}`,

web/api/ModuleBase.js

@@ -236,10 +236,11 @@ class ModuleBase {
     for (let i = 0; i < remoteSourceFields.length; i++) {
       const fieldRemote = remoteSourceFields[i];
       if (fieldRemote[1]['remote-source'] !== undefined && fieldRemote[1]['remote-source'] != null) {
-        let key = `${fieldRemote[1]['remote-source'][0]}_${fieldRemote[1]['remote-source'][1]}_${fieldRemote[1]['remote-source'][2]}`;
+        // let key = `${fieldRemote[1]['remote-source'][0]}_${fieldRemote[1]['remote-source'][1]}_${fieldRemote[1]['remote-source'][2]}`;
-        if (fieldRemote[1]['remote-source'].length === 4) {
+        // if (fieldRemote[1]['remote-source'].length === 4) {
-          key = `${key}_${fieldRemote[1]['remote-source'][3]}`;
+        //   key = `${key}_${fieldRemote[1]['remote-source'][3]}`;
-        }
+        // }
+        const key = this.getRemoteSourceKey(fieldRemote);
         this.fieldMasterDataKeys[key] = false;
 
         const callBackData = {};
@@ -1177,7 +1178,12 @@ class ModuleBase {
                 value = 'Not Selected';
               }
             } else {
-              value = this.fieldMasterData[`${rmf[0]}_${rmf[1]}_${rmf[2]}`][filters[prop]];
+              let key = `${rmf[0]}_${rmf[1]}_${rmf[2]}`;
+              if (rmf.length > 3) {
+                key = `${key}_${rmf[3]}`;
+              }
+              //value = this.fieldMasterData[`${rmf[0]}_${rmf[1]}_${rmf[2]}`][filters[prop]];
+              value = this.fieldMasterData[key][filters[prop]];
               valueOrig = value;
             }
           } else {
@@ -1332,7 +1338,8 @@ class ModuleBase {
       try {
         modJs.filterQuery();
       } catch (err) {
-        // Do Nothing
+        console.log(err);
+        console.log(err.message);
       }
       return false;
     });
@@ -2094,7 +2101,8 @@ class ModuleBase {
         $(`${formId} #${fields[i][0]}`).html(object[fields[i][0]]);
       } else if (fields[i][1].type === 'placeholder') {
         if (fields[i][1]['remote-source'] !== undefined && fields[i][1]['remote-source'] != null) {
-          const key = `${fields[i][1]['remote-source'][0]}_${fields[i][1]['remote-source'][1]}_${fields[i][1]['remote-source'][2]}`;
+          //const key = `${fields[i][1]['remote-source'][0]}_${fields[i][1]['remote-source'][1]}_${fields[i][1]['remote-source'][2]}`;
+          const key = this.getRemoteSourceKey(fields[i]);
           placeHolderVal = this.fieldMasterData[key][object[fields[i][0]]];
         } else {
           placeHolderVal = object[fields[i][0]];
@@ -2218,10 +2226,11 @@ class ModuleBase {
       if (field[1].source !== undefined && field[1].source != null) {
         t = t.replace('_options_', this.renderFormSelectOptions(field[1].source, field));
       } else if (field[1]['remote-source'] !== undefined && field[1]['remote-source'] != null) {
-        let key = `${field[1]['remote-source'][0]}_${field[1]['remote-source'][1]}_${field[1]['remote-source'][2]}`;
+        // let key = `${field[1]['remote-source'][0]}_${field[1]['remote-source'][1]}_${field[1]['remote-source'][2]}`;
-        if (field[1]['remote-source'].length === 4) {
+        // if (field[1]['remote-source'].length === 4) {
-          key = `${key}_${field[1]['remote-source'][3]}`;
+        //   key = `${key}_${field[1]['remote-source'][3]}`;
-        }
+        // }
+        const key = this.getRemoteSourceKey(field);
         t = t.replace('_options_', this.renderFormSelectOptionsRemote(this.fieldMasterData[key], field));
       }
     } else if (field[1].type === 'colorpick') {

web/components/UpdatePasswordModal.js

@@ -0,0 +1,232 @@
+import React, {Component} from 'react';
+import {
+    Form,
+    Modal,
+    Input,
+    Button,
+    message,
+} from 'antd';
+import CustomAction from '../api/CustomAction';
+
+class UpdatePasswordModal extends React.Component {
+
+    state = {
+        loading: false,
+        passwordHasError: false,
+        passwordState: { hasFeedback: false, validateStatus:'', help:'Password must include at least one number, one lowercase letter, one uppercase letter and a symbol' },
+        confirmationHasError: false,
+        confirmationState: { hasFeedback: false, validateStatus:'', help:'' },
+    };
+
+    constructor(props) {
+        super(props);
+        this.formRef = React.createRef();
+        this.customAction = new CustomAction(this.props.adapter);
+    }
+
+    componentDidMount() {
+        message.config({
+            top: 40,
+        });
+    }
+
+    clearConfirmFeedback = () => {
+        this.setState({confirmationHasError: false});
+        this.setState({
+            confirmationState: {
+                hasFeedback :  false,
+                validateStatus:'',
+                help:'',
+            }
+        });
+    }
+
+    updatePasswordState(value) {
+        const passwordValidationResult = this.validatePassword(value);
+        if (passwordValidationResult !== null) {
+            this.setState({passwordHasError: true});
+            this.setState({
+                passwordState: {
+                    hasFeedback :  true,
+                    validateStatus:'error',
+                    help:passwordValidationResult,
+                }
+            });
+
+            return false;
+        } else {
+            this.setState({passwordHasError: false});
+            this.setState({
+                passwordState: {
+                    hasFeedback :  true,
+                    validateStatus:'success',
+                    help:'',
+                }
+            });
+        }
+
+        return true;
+    }
+
+    updateConfirmPasswordState(values) {
+        if (values.confirm !== values.new) {
+            this.setState({confirmationHasError: true});
+            this.setState({
+                confirmationState: {
+                    hasFeedback :  true,
+                    validateStatus:'error',
+                    help:'Passwords don\'t match',
+                }
+            });
+
+            return false;
+        } else {
+            this.setState({confirmationHasError: false});
+            this.setState({
+                confirmationState: {
+                    hasFeedback :  false,
+                    validateStatus:'',
+                    help:'',
+                }
+            });
+        }
+
+        return true;
+    }
+
+    handleOk = () => {
+        const from = this.formRef.current;
+        from
+            .validateFields()
+            .then((values) => {
+                if (this.updatePasswordState(values.new) && this.updateConfirmPasswordState(values)) {
+                    this.updatePassword(values.current, values.new)
+                      .then((response) => {
+                        const data = response.data;
+                        console.log(data);
+                        if (data.status === 'SUCCESS') {
+                            this.handleCancel();
+                            message.success(this.props.adapter.gt('Password updated'));
+                        } else {
+                            message.error(
+                              `${this.props.adapter.gt('Error updating password')}: ${this.props.adapter.gt(data.data)}`
+                            );
+                        }
+                    }).catch((error) => {
+                        message.error(
+                          `${this.props.adapter.gt('Error updating password')}`
+                        );
+                        console.log(error.message);
+                    });
+                }
+            })
+            .catch((info) => {
+                this.setState({ loading: false });
+            });
+    }
+
+    handleCancel = () => {
+        if (this.formRef.current) {
+            this.formRef.current.resetFields();
+        }
+        this.props.closeModal();
+    }
+
+    updatePassword = (oldPassword, newPassword) => {
+        const req = { current: oldPassword ? oldPassword : '', pwd: newPassword };
+        const reqJson = JSON.stringify(req);
+
+        const callBackData = [];
+        callBackData.callBackData = [];
+        callBackData.callBackSuccess = 'changePasswordSuccessCallBack';
+        callBackData.callBackFail = 'changePasswordFailCallBack';
+
+        return this.customAction.execute('changePassword', 'modules=employees', reqJson);
+
+    }
+
+    validatePassword = (password) => {
+        if (password.length < 8) {
+            return this.props.adapter.gt('Password too short');
+        }
+
+        if (password.length > 20) {
+            return this.props.adapter.gt('Password too long');
+        }
+
+        const numberTester = /.*[0-9]+.*$/;
+        if (!password.match(numberTester)) {
+            return this.props.adapter.gt('Password must include at least one number');
+        }
+
+        const lowerTester = /.*[a-z]+.*$/;
+        if (!password.match(lowerTester)) {
+            return this.props.adapter.gt('Password must include at least one lowercase letter');
+        }
+
+        const upperTester = /.*[A-Z]+.*$/;
+        if (!password.match(upperTester)) {
+            return this.props.adapter.gt('Password must include at least one uppercase letter');
+        }
+
+        const symbolTester = /.*[\W]+.*$/;
+        if (!password.match(symbolTester)) {
+            return this.props.adapter.gt('Password must include at least one symbol');
+        }
+
+        return null;
+    }
+
+    render() {
+        const layout = {
+            labelCol: { span: 8 },
+            wrapperCol: { span: 16 },
+        };
+
+        return (
+            <Modal
+                visible={this.props.visible}
+                title="Update Password"
+                onOk={this.handleOk}
+                onCancel={this.handleCancel}
+                footer={[
+                    <Button key="back" onClick={this.handleCancel}>
+                        {this.props.adapter.gt('Cancel')}
+                    </Button>,
+                    <Button key="submit" type="primary" loading={this.state.loading} onClick={this.handleOk}>
+                        {this.props.adapter.gt('Update')}
+                    </Button>,
+                ]}
+            >
+                <Form {...layout} ref={this.formRef}>
+                    <Form.Item label="Current Password" key="current" name="current" >
+                        <Input.Password placeholder="current password"/>
+                    </Form.Item>
+                    { this.state.passwordHasError &&
+                        <Form.Item label="New Password" key="new" name="new" {...this.state.passwordState}>
+                            <Input.Password placeholder="new password" onChange={(event) => this.updatePasswordState(event.target.value)}/>
+                        </Form.Item>
+                    }
+                    { !this.state.passwordHasError &&
+                    <Form.Item label="New Password" key="new" name="new" {...this.state.passwordState}>
+                        <Input.Password placeholder="new password" onChange={(event) => this.updatePasswordState(event.target.value)}/>
+                    </Form.Item>
+                    }
+                    { this.state.confirmationHasError &&
+                    <Form.Item label="Confirm Password" key="confirm" name="confirm" {...this.state.confirmationState}>
+                        <Input.Password placeholder="confirm password" onChange={(event) => this.clearConfirmFeedback()}/>
+                    </Form.Item>
+                    }
+                    { !this.state.confirmationHasError &&
+                    <Form.Item label="Confirm Password" key="confirm" name="confirm" >
+                        <Input.Password placeholder="confirm password" onChange={(event) => this.clearConfirmFeedback()}/>
+                    </Form.Item>
+                    }
+
+                </Form>
+            </Modal>
+        )
+    }
+}
+
+export default UpdatePasswordModal;

web/modules/src/employees/components/EmployeeProfile.js

@@ -1,37 +1,32 @@
-import React, {Component} from 'react';
+import React from 'react';
 import {
   Col,
   Card,
-  Badge,
   Avatar,
-  Input,
   Row,
   Descriptions,
   Typography,
-  Table,
   Space,
-  Button,
   Tag,
-  message,
   Tabs,
-  Spin,
   Skeleton
 } from 'antd';
 import {
-  FilterOutlined,
   EditOutlined,
   PhoneTwoTone,
   MailTwoTone,
   SyncOutlined,
+  LockOutlined,
 } from '@ant-design/icons';
 import TagList from "../../../../components/TagList";
-const { Search } = Input;
+import UpdatePasswordModal from "../../../../components/UpdatePasswordModal";
 const { Title, Text } = Typography;
 const { TabPane } = Tabs;
 
 class EmployeeProfile extends React.Component {
   state = {
     loading: true,
+    showPasswordResetModal: false,
   };
 
   constructor(props) {
@@ -42,6 +37,10 @@ class EmployeeProfile extends React.Component {
     this.setState({ loading: value });
   }
 
+  setShowPasswordUpdate(value) {
+    this.setState({ showPasswordResetModal: value });
+  }
+
   updateProfileImage() {
     showUploadDialog(
       `profile_image_${this.props.element.id}_${(new Date()).getTime()}`,
@@ -71,6 +70,33 @@ class EmployeeProfile extends React.Component {
     </>);
   }
 
+  getEditButtonJsxWithPassword() {
+    return (<>
+      {this.state.loading &&
+      <Tag icon={<SyncOutlined spin/>} color="processing">
+        {this.props.adapter.gt('Edit')}
+      </Tag>
+      }
+      {!this.state.loading &&
+      <Tag icon={<EditOutlined/>} color="processing"
+           onClick={() => modJs.edit(this.props.element.id)}>
+        {this.props.adapter.gt('Edit')}
+      </Tag>
+      }
+      <Tag icon={<LockOutlined/>} color="volcano" onClick={() => this.setShowPasswordUpdate(true)}>
+      {this.props.adapter.gt('Update Password')}
+      </Tag>
+    </>);
+  }
+
+  getUpdatePasswordButtonJsx() {
+    return (<>
+      <Tag icon={<SyncOutlined spin/>} color="processing">
+        {this.props.adapter.gt('Update Password')}
+      </Tag>
+    </>);
+  }
+
   getTabViewEmployeeFilterButtonJsx(tab) {
     return (
       <Tag icon={<EditOutlined/>} color="processing"
@@ -86,10 +112,15 @@ class EmployeeProfile extends React.Component {
     }
     return (
       <>
+      <UpdatePasswordModal
+          visible={this.state.showPasswordResetModal}
+          closeModal={() => {this.setState({ showPasswordResetModal: false })}}
+          adapter={this.props.adapter}
+      />
       <Row direction="vertical" style={{width: '100%', padding: '10px'}} gutter={24}>
         <Col span={24}>
           <Card title={this.props.adapter.gt('Employee Profile')}
-                extra={this.getEditButtonJsx()}
+                extra={this.getEditButtonJsxWithPassword()}
                 style={{ width: '100%' }}
           >
             <Space size={'large'}>

web/modules/src/time_sheets/lib.js

@@ -613,8 +613,15 @@ class EmployeeTimeEntryAdapter extends AdapterBase {
     return dateArray;
   }
 
-
   renderForm(object) {
+    this.initMasterDataReader();
+    this.masterDataReader.updateAllMasterData()
+      .then(() => {
+        this._renderForm(object);
+      });
+  }
+
+  _renderForm(object) {
     let formHtml = this.getCustomTemplate('time_entry_form.html');
     formHtml = formHtml.replace(/modJs/g, "modJsList['tabEmployeeTimeEntry']");
     let html = '';