aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.DB/ViewModels/RolesViewVM.cs
blob: e87aa767daabe22afd821cab7a12c13bfd545482 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.DB.ViewModels;

namespace Tango.MachineStudio.DB.ViewModels
{
    public class RolesViewVM : DbTableViewModel<Role>
    {
        public RolesViewVM(INotificationProvider notification) : base(notification)
        {
            SelectedPermissions = new ObservableCollection<MultiComboVM<Permission>>();
        }

        private ObservableCollection<MultiComboVM<Permission>> _selectedPermissions;
        public ObservableCollection<MultiComboVM<Permission>> SelectedPermissions
        {
            get { return _selectedPermissions; }
            set { _selectedPermissions = value; RaisePropertyChangedAuto(); }
        }

        protected override void OnEdit()
        {
            SelectedPermissions = Adapter.Permissions.Select(x => new MultiComboVM<Permission>(x, () => RaisePropertyChanged(nameof(SelectedPermissions)))).ToObservableCollection();

            foreach (var permission in SelectedPermissions)
            {
                if (SelectedEntity.RolesPermissions.ToList().Exists(x => x.Permission == permission.Entity))
                {
                    permission.IsSelected = true;
                }
            }

            base.OnEdit();
        }

        protected override void OnAdd()
        {
            SelectedPermissions = Adapter.Permissions.Select(x => new MultiComboVM<Permission>(x, () => RaisePropertyChanged(nameof(SelectedPermissions)))).ToObservableCollection();

            base.OnAdd();
        }

        protected override void OnBeforeEntitySave(DialogOpenMode mode, Role role)
        {
            base.OnBeforeEntitySave(mode, role);

            Adapter.Context.RolesPermissions.RemoveRange(role.RolesPermissions);

            foreach (var permission in SelectedPermissions)
            {
                if (permission.IsSelected)
                {
                    role.RolesPermissions.Add(new RolesPermission()
                    {
                        Permission = permission.Entity,
                        Role = role,
                        PermissionGuid = permission.Entity.Guid,
                        RoleGuid = role.Guid
                    });
                }
            }
        }
    }
}
teral.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
#include <PMR/Common/MessageContainer.pb-c.h>
#include "include.h"
#include "driverlib/gpio.h"

//#include "usb_serial_adapter.h"
//#include "graphics_adapter.h"
#include "Modules/Stubs_Handler/Calculate.h"
#include "Modules/Stubs_Handler/Progress.h"
#include "Modules/Stubs_Handler/Procedure.h"
#include "Modules/Stubs_Handler/Stub_Cartridge.h"
#include "Modules/Stubs_Handler/Stub_Dispenser.h"
#include "Modules/Stubs_Handler/Stub_GPIO.h"
#include "Modules/Stubs_Handler/Stub_Heater.h"
#include "Modules/Stubs_Handler/Stub_OptLimitSwitch.h"
#include "Modules/Stubs_Handler/Stub_SteperMotor.h"
#include "Modules/Stubs_Handler/Stub_Valve.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadBackReg.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadVersion.h"
//#include "Modules/Stubs_Handler/Stub_L6470.h"
#include "Modules/Stubs_Handler/Stub_Motor.h"
#include "Modules/Stubs_Handler/Stub_HW_Version.h"
#include "Modules/Stubs_Handler/Stub_FPGARWReg.h"
#include "Modules/Stubs_Handler/Stub_ReadEmbeddedVersion.h"
#include "Modules/Stubs_Handler/Stub_TivaReg.h"
#include "Modules/Stubs_Handler/Stub_Dancer.h"
#include "Modules/Stubs_Handler/Stub_SpeedSensor.h"
#include "Modules/Stubs_Handler/Stub_IntADC.h"
#include "Modules/Stubs_Handler/StubRealTimeUsage.h"
#include "Modules/Stubs_Handler/Stub_TempSensor.h"
#include "Modules/Stubs_Handler/Stub_I2C.h"
#include "Modules/Stubs_Handler/Stub_MidTankPressureSensor.h"

#include "Modules/General/GeneralHardware.h"
#include "Modules/General/MachineStatus.h"
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include "Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h"

#include "Modules/heaters/heaters_ex.h"
#include "Modules/AlarmHandling/AlarmHandling.h"
#include "modules/Diagnostics/Diagnostics.h"

#include "Modules/General/process.h"
#include "Modules/Thread/Thread_ex.h"
#include "Modules/Ids/Ids_ex.h"
#include "Modules/waste/waste_ex.h"
#include "Modules/Ifs/Ifs.h"

#include "Common/SWUpdate/FileSystem.h"
#include "Common/SWUpdate/FirmwareUpgrade.h"
#include "Communication/CommunicationTask.h"

#include "drivers/Flash_ram/MCU_E2Prom.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/PowerIdle.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/InitSequence.h"

#include "Common/report/report.h"
#include "Connection.h"
#include "Modules/IFS/ifs.h"

#define  MAX_CONT_LOG 199

/*uint16_t TxmsgId[MAX_CONT_LOG+1] = {0};
uint16_t TxLength[MAX_CONT_LOG+1] = {0};
uint32_t TxAddr[MAX_CONT_LOG+1] = {0};
uint16_t Txindex = 0;
uint32_t msgId[MAX_CONT_LOG+1] = {0};
uint32_t Length[MAX_CONT_LOG+1] = {0};
uint32_t DataLength[MAX_CONT_LOG+1] = {0};
byte RxIndex = 0;*/


MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*))
{
    MessageContainer container = MESSAGE_CONTAINER__INIT;
    container.completed = completed;
    container.token = token;
    container.has_completed = true;
    container.has_data = true;
    container.has_type = true;
    container.type = type;

    uint8_t* response_buffer = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    /*if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }*/

    //free(response);
    return container;
}
MessageContainer createAllocatedContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*),uint8_t* response_buffer)
{
    MessageContainer container = MESSAGE_CONTAINER__INIT;
    container.completed = completed;
    container.token = token;
    container.has_completed = true;
    container.has_data = true;
    container.has_type = true;
    container.type = type;

    //uint8_t* response_buffer = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    /*if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }*/

    //free(response);
    return container;
}

void receive_callback(char* buffer, size_t length)
{

     MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
     if (requestContainer == NULL)
         return;
#ifndef DISPESER_TEST
    if ((requestContainer->type>= MESSAGE_TYPE__StartDiagnosticsRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveResponse)) //user action resets the idle counter
    {
         ReportWithPackageFilter(CommFilter,"Message received", __FILE__,__LINE__,requestContainer->type, RpMessage,length, 0);
    }
#endif
    if ((requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveResponse))
        resetIdleCounter();
    //ReportWithPackageFilter(CommFilter,"Message received", __FILE__,__LINE__,requestContainer->type, RpMessage,length, 0);
    if (keepalivetest == false)
        KeepAliveOneSecondCounter = 0;
     /*msgId[RxIndex] = requestContainer->type;
     Length[RxIndex] = length;
     DataLength[RxIndex] = msec_millisecondCounter;
     if (RxIndex++>=MAX_CONT_LOG)
         RxIndex = 0;*/
     switch(requestContainer->type)
     {
         case MESSAGE_TYPE__CalculateRequest:
             Stub_CalculateRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ProgressRequest:
             Stub_ProgressRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ProcedureRequest:
             Stub_ProcedureRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeReadRequest:
             Stub_CartridgeReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeWriteRequest:
             Stub_CartridgeWriteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubDispenserRequest:
             Stub_DispenserRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOInputSetupRequest:
             Stub_GPIOInputSetupRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadBitRequest:
             Stub_GPIOReadBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadByteRequest:
             Stub_GPIOReadByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteBitRequest:
             Stub_GPIOWriteBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteByteRequest:
             Stub_GPIOWriteByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeaterRequest:
             Stub_HeaterRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CRequest:
             Stub_I2CRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubOptLimitSwitchRequest:
//             Stub_OptLimitSwitchRequest(requestContainer);
//             break;
//         case MESSAGE_TYPE__StubSteperMotorRequest:
//             Stub_SteperMotorRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubValveRequest:
             Stub_ValveRequest(requestContainer);
             break;
//		case MESSAGE_TYPE__StubFPGAReadBackRegRequest:
//             Stub_FPGAReadBackRegRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubFPGAReadVersionRequest:
             Stub_FPGAReadVersionRequest(requestContainer);
             break;
             /*************************************/
         case MESSAGE_TYPE__StubFpgaReadRegRequest:
             Stub_FpgaReadRegRequest(requestContainer);
             break;
         case    MESSAGE_TYPE__StubFpgaWriteRegRequest:
             Stub_FpgaWriteRegRequest(requestContainer);
             break;
             /*************************************/
//         case MESSAGE_TYPE__StubL6470DriverRequest:
//             Stub_L6470DriverRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubMotorInitRequest:
             Stub_MotorInitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRunRequest:
             Stub_MotorRunRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStopRequest:
             Stub_MotorStopRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStatusRequest:
             Stub_MotorStatusRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorPositionRequest:
             Stub_MotorPositionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorSpeedRequest:
             Stub_MotorSpeedRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRequest:
             Stub_MotorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorMovRequest:
             Stub_MotorMovRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubJobRequest:
             Stub_JobRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubAbortJobRequest:
             Stub_AbortJobRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubHWVersionRequest:
//             Stub_HWVersionRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StartDebugLogRequest:
             ReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__StopDebugLogRequest:
             StopReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__SetDebugLogCategoryRequest:
             SetDebugLogCategoryFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetupDebugDisributorsRequest:
             SetupDebugDisributorsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__JobRequest:
             JobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortJobRequest:
             JobAbortFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CurrentJobRequest:
             CurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ResumeCurrentJobRequest:
             ResumeCurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartHeadCleaningRequest:
             ThreadCleaningJobFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortHeadCleaningRequest:
             ThreadCleaningAbortJobFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadHardwareConfigurationRequest:
             HWConfigurationFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadProcessParametersRequest:
             ProcessRequestFunc(requestContainer);
             break;
             //functions stolen for thread load process tests
//             void ThreadLoadPollRequest(MessageContainer* requestContainer)
//             void ThreadLoadRequest(MessageContainer* requestContainer)
//             HeatingTestRequest(requestContainer);
//             HeatingTestPollRequest(requestContainer);
         case MESSAGE_TYPE__StubHeatingTestRequest:
             ThreadLoadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeatingTestPollRequest:
             ThreadLoadPollRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubReadEmbeddedVersionRequest:
             Stub_ReadEmbeddedVersionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__SystemResetRequest:
             HWSystemResetRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubTivaReadRegRequest:
//             Stub_TivaReadRegRequest(requestContainer);
//             break;
//         case MESSAGE_TYPE__StubTivaWriteRegRequest:
//             Stub_TivaWriteRegRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubDancerPositionRequest:
             Stub_DancerPositionRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubSpeedSensorRequest:
//             Stub_SpeedSensorRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubRealTimeUsageRequest:
             Stub_RealTimeUsageRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubIntADCReadRequest:
             Stub_IntADCReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubTempSensorRequest:
             Stub_TempSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ConnectRequest:
             ConnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DisconnectRequest:
             DisconnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StartDiagnosticsRequest:
             StartDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopDiagnosticsRequest:
             StopDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartEventsNotificationRequest:
             StartEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetHeaterStateRequest:
             SetHeaterStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopEventsNotificationRequest:
             StopEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ResolveEventRequest:
             ResolveEventRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortHomingRequest:
            MotorAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorHomingRequest:
            MotorHomingRequestFunc(requestContainer);
            break;
         case MESSAGE_TYPE__MotorJoggingRequest:
            MotorJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortJoggingRequest:
            MotorAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortHomingRequest:
            DispenserAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserHomingRequest:
            DispenserHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserJoggingRequest:
            DispenserJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortJoggingRequest:
            DispenserAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetComponentValueRequest:
             SetComponentValueRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetDigitalOutRequest:
             SetDigitalOutRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetValveStateRequest:
             SetValveStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetBlowerStateRequest:
             SetBlowerStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadJoggingRequest:
             ThreadJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadAbortJoggingRequest:
             ThreadAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CReadBytesRequest:
             Stub_I2CReadBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CWriteBytesRequest:
             Stub_I2CWriteBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__KeepAliveRequest:
             KeepAliveRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__KeepAliveResponse:
             KeepAliveResponseFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileUploadRequest:
             FileUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkUploadRequest:
             FileChunkUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileDownloadRequest:
             FileDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkDownloadRequest:
             FileChunkDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ExecuteProcessRequest:
             ExecuteProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__KillProcessRequest:
             KillProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CreateRequest:
             CreateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DeleteRequest:
             DeleteRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetStorageInfoRequest:
             GetStorageInfoRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetFilesRequest:
             GetFilesRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ActivateVersionRequest:
             ActivateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ValidateVersionRequest:
             ValidateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubMidTankPressureSensorRequest:
             Stub_MidTankPressureSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserDataRequest:
             DispenserDataRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CartridgeValidationResponse:
             CartridgeValidationResponseFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartInkFillingStatusRequest:
             StartInkFillingStatusRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MidTankDataSetupRequest:
             MidTankDataSetupFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MachineCalibrationDataRequest:
             MachineCalibrationDataRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MainCardStoredDataRequest:
             MainCardStoredItemRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartMachineStatusUpdateRequest:
             MachineUpdateInitFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopMachineStatusUpdateRequest:
             StopMachineUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartPowerDownRequest:
             PowerDownUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortPowerDownRequest:
             AbortPowerDownFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartPowerUpRequest:
             PowerUpUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortPowerUpRequest:
             AbortPowerUpFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartThreadLoadingRequest:
             StartThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ContinueThreadLoadingRequest:
             ContinueThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopThreadLoadingRequest:
             StopThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AttemptThreadJoggingRequest:
             AttemptThreadJoggingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubDispenserEEpromRequest:
             StubDispenserEEpromRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubWhsEEpromRequest:
             WhsEEpromRequestFunc(requestContainer);
             break;
       case MESSAGE_TYPE__StubMainCardEEpromReadRequest:
             MainCardEEpromReadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubMainCardEEpromWriteRequest:
             MainCardEEpromWriteRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__TryThreadLoadingRequest:
             TryThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StandByRequest:
             StandByRequestFunc(requestContainer);
             break;
         default:
             //unsupported message type !!
             LOG_ERROR (requestContainer->type,"unsupported message type");
             break;
     }
     message_container__free_unpacked(requestContainer, NULL);

}
bool SendResult,KeepSendResult = true;
/*uint16_t SendmsgId[MAX_CONT_LOG+1] = {0};
uint16_t SendSize[MAX_CONT_LOG+1] = {0};
uint32_t SendTime[MAX_CONT_LOG+1] = {0};
bool Sendresult[MAX_CONT_LOG+1] = {0};
uint16_t Sendindex = 0;*/
bool SendChars(char* buffer,size_t length)
{
/*    SendmsgId[Sendindex] = 0xFFFF;
    SendSize[Sendindex] = length;
    SendTime[Sendindex] = msec_millisecondCounter;
    if (Sendindex++>=MAX_CONT_LOG)
        Sendindex = 0;*/
    SendResult = CommunicationTaskSendMessage(buffer, length);
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}
bool SendCharsWithType(char* buffer,size_t length,MessageType type)
{
//    SendmsgId[Sendindex] = type;
//    SendSize[Sendindex] = length;
//    SendTime[Sendindex] = msec_millisecondCounter;

    SendResult = CommunicationTaskSendMessage(buffer, length);

//    Sendresult[Sendindex] = SendResult;
    //if (Sendindex++>=MAX_CONT_LOG)
    //    Sendindex = 0;
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}