Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 15358 | Rev 16766 | Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;


use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Model\Company;
use LeadersLinked\Mapper\ServiceMapper;
use LeadersLinked\Mapper\CompanyServiceMapper;
use LeadersLinked\Mapper\RoleMapper;
use LeadersLinked\Mapper\CompanyRoleMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Model\CompanyService;
use LeadersLinked\Mapper\CompanyUserRoleMapper;
use LeadersLinked\Model\Role;
use LeadersLinked\Model\CompanyRole;
use LeadersLinked\Model\CompanyUserRole;
use LeadersLinked\Model\CompanyUser;
use Google\Service\Directory\UserMakeAdmin;
use LeadersLinked\Mapper\NetworkMapper;
use LeadersLinked\Model\Service;

class CompanyController extends AbstractActionController
{
    /**
     *
     * @var AdapterInterface
     */
    private $adapter;
    
    
    /**
     *
     * @var AbstractAdapter
     */
    private $cache;
    
    /**
     *
     * @var  LoggerInterface
     */
    private $logger;

    /**
     *
     * @var array
     */
    private $config;
    
    
    
    /**
     *
     * @param AdapterInterface $adapter
     * @param AbstractAdapter $cache
     * @param LoggerInterface $logger
     * @param array $config
     */
    public function __construct($adapter, $cache , $logger, $config)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;

        
    }
    
    public function indexAction()
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser    = $currentUserPlugin->getUser();
        
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $network = $currentNetworkPlugin->getNetwork();
        
        if($request->isGet()) {
            
            
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                    
                }
            }
            
            if($isJson) {
                
                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                $allowServices = $acl->isAllowed($currentUser->usertype_id, 'companies/services');
                $allowRoles = $acl->isAllowed($currentUser->usertype_id, 'companies/roles');
                $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'companies/edit');
                
                
                $serviceMapper = ServiceMapper::getInstance($this->adapter);
                $records = $serviceMapper->fetchAll(); 
                
                $services = []; 
                foreach($records as $record) 
                {
                    $services[ $record->id ] = $record->name;
                } 
                 
                
                $roleMapper = RoleMapper::getInstance($this->adapter);
                $records = $roleMapper->fetchAll();
         
                $roles = [];
                foreach($records as $record)
                {
                    $roles[ $record->id ] = $record->name;
                } 
                
                $networkMapper = NetworkMapper::getInstance($this->adapter);
                $records = $networkMapper->fetchAll();
                
                $networks = [];
                foreach($records as $record)
                {
                    $networks[ $record->id ] = $network;
                }
                
                
                
                    
                
                $search = $this->params()->fromQuery('search', []);
                $search = empty($search['value']) ? '' : filter_var($search['value'], FILTER_SANITIZE_STRING);
                
                $page               = intval($this->params()->fromQuery('start', 1), 10);
                $records_x_page     = intval($this->params()->fromQuery('length', 10), 10);
                $order =  $this->params()->fromQuery('order', []);
                $order_field        = empty($order[0]['column']) ? 99 :  intval($order[0]['column'], 10);
                $order_direction    = empty($order[0]['dir']) ? 'ASC' : strtoupper(filter_var( $order[0]['dir'], FILTER_SANITIZE_STRING));
    
                $fields =  ['name'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'name';
                
                if(!in_array($order_direction, ['ASC', 'DESC'])) {
                    $order_direction = 'ASC';
                }
                
                $status = filter_var($this->params()->fromQuery('status'), FILTER_SANITIZE_STRING);
                if(!in_array($status, [
                    Company::STATUS_ACTIVE,
                    Company::STATUS_DELETED,
                    Company::STATUS_INACTIVE,
                    Company::STATUS_PENDING,
                    Company::STATUS_REJECTED
                ])) {
                    $status = '';
                }
                
                $network_id = filter_var($this->params()->fromQuery('network_id'), FILTER_SANITIZE_STRING);
                
                $network = $networkMapper->fetchOneByUuid($network_id);
                if($network) {
                    $network_id = $network->id; 
                } else {
                    $network_id = 0;
                }
                
    
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $paginator = $companyMapper->fetchAllDataTable($search, $page, $status, $network_id, $records_x_page, $order_field, $order_direction);
                
                $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);
                $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $userMapper = UserMapper::getInstance($this->adapter);
                

                
                $items = [];
                $records = $paginator->getCurrentItems();
                foreach($records as $record)
                {
                    $security = [
                        'first_name' => '',
                        'last_name' => '',
                        'email' => '',
                    ]; 
                    
                    $companyUser = $companyUserMapper->fetchCreatorByCompanyId($record->id);
                    if($companyUser) {
                        $user = $userMapper->fetchOne($companyUser->user_id); 
                        if($user) {
                            $security['first_name'] = $user->first_name;
                            $security['last_name'] = $user->last_name;
                            $security['email'] = $user->email;
                        } 
                    }
                    
                    $companyServices = $companyServiceMapper->fetchAllByCompanyId($record->id); 
                    $companyRoles = $companyRoleMapper->fetchAllByCompanyId($record->id);
                    
                    
                    $details['services'] = [] ;
                   
                    foreach($companyServices as $companyService)
                    {
                        if($companyService->status == CompanyService::ACTIVE) {
                        
                            
                            array_push($details['services'], $services[$companyService->service_id]);
                        }
                    }
                    
                    $details['roles'] = [] ;
                    
                    foreach($companyRoles as $companyRole)
                    {
                        array_push($details['roles'], $roles[$companyRole->role_id]);
                    }
                    
                    
 
                    
                    
                    $details['internal'] = $record->internal == Company::INTERNAL_YES ? 'LABEL_YES' : 'LABEL_NO';
                   
                 
                    $link_profile = '';
                    switch($record->status)
                    {
                        case Company::STATUS_PENDING : 
                            $details['status'] = 'LABEL_PENDING';
                            
                            break; 
                            
                        case Company::STATUS_ACTIVE : 
                            $link_profile = 'https://'. $networks[$record->network_id]->main_hostname . '/company/view/' . $record->uuid;
                            $details['status'] = 'LABEL_ACTIVE';
                            break;
                            
                        case Company::STATUS_INACTIVE : 
                            $details['status'] = 'LABEL_INACTIVE';
                            break;
                            
                        case Company::STATUS_REJECTED : 
                            $details['status'] = 'LABEL_REJECTED';
                            break;
                            
                        case Company::STATUS_DELETED : 
                            $details['status'] = 'LABEL_DELETED';
                            break;
                            
                        default : 
                            $details['status'] = 'LABEL_UNKNOWN';
                            break;
                    }
                    
                
                    $item = [
                        'id' => $record->id,
                        'name' => $record->name,
                        'network' => $networks[$record->network_id]->name,
                        'link_profile' => $link_profile,
                        'details' => $details,
                        'security' => $security,
                        'actions' => [
                           'link_services' => $allowServices ? $this->url()->fromRoute('companies/services', ['id' => $record->uuid ]) : '',
                           'link_roles' => $allowRoles ? $this->url()->fromRoute('companies/roles', ['id' => $record->uuid ]) : '',
                           'link_edit' => $allowEdit ? $this->url()->fromRoute('companies/edit', ['id' => $record->uuid ]) : '',  
                        ] 
                        
                    ];
                    
                    array_push($items, $item);
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'items' => $items,
                        'total' => $paginator->getTotalItemCount(),
                    ]
                ]);
            } else  {
                
                $networkMapper = NetworkMapper::getInstance($this->adapter);
                $records = $networkMapper->fetchAll();
                
                $networks = [];
                foreach($records as $record)
                {
                    $networks[ $record->uuid ] = $record->name;
                }
                
                
                
                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/companies/index.phtml');
                $viewModel->setVariables(['networks' => $networks ]);
                return $viewModel ;
            }
      
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function servicesAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        
        if(!$uuid) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOneByUuid($uuid);
        if(!$company) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_COMPANY_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if($request->isPost()) {
             
            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);

            $serviceMapper = ServiceMapper::getInstance($this->adapter);
            $services = $serviceMapper->fetchAll(); 
            
            foreach($services as $service)
            {
                $status     = filter_var( $this->params()->fromPost('status' . $service->id), FILTER_SANITIZE_STRING);
                $paid_from  = filter_var( $this->params()->fromPost('paid_from' . $service->id), FILTER_SANITIZE_STRING);
                $paid_to    = filter_var( $this->params()->fromPost('paid_to' . $service->id), FILTER_SANITIZE_STRING);
           
                $ok = true;
                switch ($status) { 
                
                    case CompanyService::ACTIVE : 
                    case CompanyService::CANCELLED : 
                    case CompanyService::SUSPENDED : 
                    
                        $dt_paid_from = \DateTime::createFromFormat('d/m/Y', $paid_from); 
                        $dt_paid_to = \DateTime::createFromFormat('d/m/Y', $paid_to); 
                    
                        if(!$dt_paid_from || !$dt_paid_to) {
                            $ok = false;
                        }  else {
                            if($dt_paid_from->getTimestamp() > $dt_paid_to->getTimestamp()) {
                                $ok = false; 
                            } else {
                                $dt_paid_from->setTime(0, 0, 0);
                                $paid_from = $dt_paid_from->format('Y-m-d');
                                
                                
                                $dt_paid_to->setTime(23, 59, 59);
                                $paid_to = $dt_paid_to->format('Y-m-d');
                            } 
                        }  
                    
                        break;
                        
                    case CompanyService::INACTIVE : 
                        $paid_from = null;
                        $paid_to = null;
                        break;
                        
                    default : 
                        $ok = false;
                        break;
                    
                    
                }
                
                if(!$ok) {
                    return new JsonModel([
                        'success' => false, 
                        'data' => 'ERROR_PARAMETERS_ARE_INVALID'
                    ]); 
                }
                
                
                $companyService = $companyServiceMapper->fetchOneByCompanyIdAndServiceId($company->id, $service->id);
                if($companyService) {
                    
                    $companyService->status = $status;
                    $companyService->paid_from = $paid_from;
                    $companyService->paid_to = $paid_to;
                    
                    if(!$companyServiceMapper->update($companyService)) {
                        return new JsonModel([
                            'success' => false,
                            'data' => $companyServiceMapper->getError()
                        ]);
                    } 
                    
                    
                } else {
                    $companyService = new CompanyService(); 
                    $companyService->service_id = $service->id;
                    $companyService->company_id = $company->id;
                    $companyService->status = $status;
                    $companyService->paid_from = $paid_from; 
                    $companyService->paid_to = $paid_to;
                    
                    
                    if(!$companyServiceMapper->insert($companyService)) {
                        return new JsonModel([
                            'success' => false,
                            'data' => $companyServiceMapper->getError()
                        ]); 
                    } 
                } 
                
                
            }
            
            $this->logger->info('Se actualizo los servicios de la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
  
            return new JsonModel([
                'success' => true,
                'data' => 'LABEL_RECORD_UPDATED'
            ]);
                

        } else if ($request->isGet()) {
            
           
            
            $serviceMapper = ServiceMapper::getInstance($this->adapter);
            $records = $serviceMapper->fetchAll(); 
            
            $services = [];
            foreach($records as $record)
            {
                if($company->default_for_network == Company::DEFAULT_FOR_NETWORK_NO) {
                    if($record->default_company_is_required == Service::DEFAULT_COMPANY_IS_REQUIRED_YES) {
                        continue;
                    }
                }
                
                
                $services[ $record->id ] = [
                    'id'        => $record->id,
                    'name'      => $record->name,
                    'status'    => '',
                    'paid_from' => '',
                    'paid_to'   => '',
                ];
            }
            
            
            
            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);
            $records = $companyServiceMapper->fetchAllByCompanyId($company->id);
            

            foreach($records as $record)
            {
                $paid_from = '';
                if($record->paid_from) {
                    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->paid_from); 
                    if($dt) {
                        $paid_from = $dt->format('d/m/Y');
                    }
                    
                } 
                
                $paid_to = '';
                if($record->paid_to) {
                    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->paid_to);
                    if($dt) {
                        $paid_to = $dt->format('d/m/Y');
                    }
                    
                } 
                
                
                $services[ $record->service_id ] ['status']  = $record->status;
                $services[ $record->service_id ] ['paid_from']  = $paid_from;
                $services[ $record->service_id ] ['paid_to']  = $paid_to;
  
            }
            
            $data = [
                'success' => true, 
                'data' => $services,
            ]; 
            
            
            
            return new JsonModel($data);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    

    public function rolesAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        
        if(!$uuid) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOneByUuid($uuid);
        if(!$company) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_COMPANY_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if($request->isPost()) {
            
            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($this->adapter);
            
            $roleMapper = RoleMapper::getInstance($this->adapter);
            $roles = $roleMapper->fetchAll(); 
            
            
            foreach($roles as $role)
            {
                $companyRole = $companyRoleMapper->fetchOneByCompanyIdAndRoleId($company->id, $role->id);
                $checked     = filter_var( $this->params()->fromPost('checked' . $role->id), FILTER_SANITIZE_NUMBER_INT);
                
                if($checked) {
                    
                    if(!$companyRole) {
                        $companyRole = new CompanyRole(); 
                        $companyRole->company_id = $company->id; 
                        $companyRole->role_id = $role->id;
                        
                        if(!$companyRoleMapper->insert($companyRole)) {
                            return new JsonModel([
                                'success' => false, 
                                'data' => $companyRoleMapper->getError()
                            ]); 
                        } 
                        
                    }
                    
                } else {
                    if($companyRole) {
                        $companyUserRoleMapper->deleteByCompanyIdAndRoleId($company->id, $role->id);
                        $companyRoleMapper->deleteByCompanyIdAndRoleId($company->id, $role->id);
                    }
                    
                }
            }
            
            $this->logger->info('Se actualizo los roles de la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
            
            return new JsonModel([
                'success' => true,
                'data' => 'LABEL_RECORD_UPDATED'
            ]);
            
            
        } else if ($request->isGet()) {
            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);
            
            $roleMapper = RoleMapper::getInstance($this->adapter);
            $records = $roleMapper->fetchAll(); 
            
           
            
            $roles = []; 
            foreach($records as $record)
            {
                if($record->service_id) {
                    $companyService = $companyServiceMapper->fetchOneByCompanyIdAndServiceId($company->id, $record->service_id);

                    if(!$companyService || $companyService->status == CompanyService::INACTIVE) {
                        continue;
                    } 
                    
                }
                
               
                
                $roles[ $record->id ] = [
                   'id' => $record->id, 
                   'name' => $record->name,
                   'fixed' => $record->creator == Role::CREATOR_YES ? true : false,
                   'checked' => $record->creator == Role::CREATOR_YES ? true : false,
                ];
            }
            
            
            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);
            $records = $companyRoleMapper->fetchAllByCompanyId($company->id);
            
            foreach($records as $record)
            {
                $roles[ $record->role_id ]['checked'] = true; 
                
            }
            
            $data = [
                'success' => true,
                'data' => $roles,
            ];
            
            
            
            return new JsonModel($data);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    public function editAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        
        if(!$uuid) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOneByUuid($uuid);
        if(!$company) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_COMPANY_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if($request->isPost()) {
            
            
            $status = filter_var( $this->params()->fromPost('status', FILTER_SANITIZE_STRING));
            $user_uuid = filter_var( $this->params()->fromPost('user_uuid', FILTER_SANITIZE_STRING));
            
            
            if(!in_array($status, [
                Company::STATUS_ACTIVE,
                Company::STATUS_INACTIVE,
                Company::STATUS_DELETED,
                Company::STATUS_PENDING,
                Company::STATUS_REJECTED,
                
            ])) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_PARAMETERS_ARE_INVALID'
                ]);
            } 
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($user_uuid); 
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $user->id);
            
            if(!$companyUser) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_COMPANY_USER_NOT_FOUND'
                ]);
            }
            
            
            if($companyUser->status != CompanyUser::STATUS_ACCEPTED && $companyUser->status != CompanyUser::STATUS_ADMIN_WILL_ADD) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_COMPANY_USER_IS_NOT_ACTIVE'
                ]);
            }
            
            $creator = $companyUserMapper->fetchCreatorByCompanyId($company->id);
            if($creator->user_id != $user->id) {
                
                $creator->creator = CompanyUser::CREATOR_NO;
                $creator->backend = CompanyUser::BACKEND_NO;
                $companyUserMapper->update($creator); 
                
                $companyUser->creator = CompanyUser::CREATOR_YES; 
                $companyUser->backend = CompanyUser::BACKEND_YES;
                $companyUserMapper->update($companyUser);
                
            } 
            
            $company->status = $status;
            if($companyMapper->update($company)) {
                
                $this->logger->info('Se edito la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success' => true,
                    'data' => 'LABEL_RECORD_UPDATED'
                ]);
            }  else {
                return new JsonModel([
                    'success' => false,
                    'data' => $companyMapper->getError(),
                ]);
            } 
            
            
            
            
            
            
        } else if ($request->isGet()) {
            $userMapper = UserMapper::getInstance($this->adapter);
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $records = $companyUserMapper->fetchAllByCompanyId($company->id); 
            
            $users = [] ;
            foreach($records as $record)
            {
                if($record->owner == CompanyUser::OWNER_YES) {
                    continue; 
                } 
                
                
                if($record->status != CompanyUser::STATUS_ACCEPTED && $record->status != CompanyUser::STATUS_ADMIN_WILL_ADD) {
                    continue;
                }
                
                $user = $userMapper->fetchOne($record->user_id);
                
                array_push($users, [
                    'uuid' => $user->uuid,
                    'name' => trim($user->first_name . ' ' . $user->last_name) . ' (' . $user->email . ')',
                    
                ] );
                
                
                
                
                
                
            }
            
            usort($users, function($a, $b) {
                return $a['name'] <=> $b['name'];
            }); 
            
            
            $creator = $companyUserMapper->fetchCreatorByCompanyId($company->id);
            if($creator) {
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOne($creator->user_id); 
                if($user) {
                    $creator = $user->uuid; 
                } else {
                    $creator = '';
                } 
            } else {
                $creator = '';
            } 
            
            $data = [
                'success' => true,
                'data' => [
                    'status' => $company->status,
                    'users' => $users,
                    'creator' => $creator,
                ],
            ];
            
            
            
            return new JsonModel($data);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
}