tvpl.api

<back to all web services

GetWorkflowStepRequest

Requires Authentication
The following routes are available for this service:
GET/WorkflowStep/by-workflow
import 'package:servicestack/servicestack.dart';

class WorkflowStep implements IConvertible
{
    int? id;
    // @References(typeof(Document))
    int? workflowId;

    int? stepOrder;
    // @required()
    // @StringLength(255)
    String? stepName;

    // @required()
    bool? isRequired;

    int? slaLegalValue;
    bool? slaLegalIsByDay;
    int? slaInternalValue;
    bool? slaInternalIsByDay;
    bool? requireAttachment;
    // @required()
    String? description;

    int? createdBy;
    // @ignore()
    List<int>? departmentIds;

    // @ignore()
    List<int>? stepBasisDocumentIds;

    // @ignore()
    List<int>? stepAttachedIds;

    // @ignore()
    List<int>? mainAssigneeIds;

    WorkflowStep({this.id,this.workflowId,this.stepOrder,this.stepName,this.isRequired,this.slaLegalValue,this.slaLegalIsByDay,this.slaInternalValue,this.slaInternalIsByDay,this.requireAttachment,this.description,this.createdBy,this.departmentIds,this.stepBasisDocumentIds,this.stepAttachedIds,this.mainAssigneeIds});
    WorkflowStep.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        workflowId = json['workflowId'];
        stepOrder = json['stepOrder'];
        stepName = json['stepName'];
        isRequired = json['isRequired'];
        slaLegalValue = json['slaLegalValue'];
        slaLegalIsByDay = json['slaLegalIsByDay'];
        slaInternalValue = json['slaInternalValue'];
        slaInternalIsByDay = json['slaInternalIsByDay'];
        requireAttachment = json['requireAttachment'];
        description = json['description'];
        createdBy = json['createdBy'];
        departmentIds = JsonConverters.fromJson(json['departmentIds'],'List<int>',context!);
        stepBasisDocumentIds = JsonConverters.fromJson(json['stepBasisDocumentIds'],'List<int>',context!);
        stepAttachedIds = JsonConverters.fromJson(json['stepAttachedIds'],'List<int>',context!);
        mainAssigneeIds = JsonConverters.fromJson(json['mainAssigneeIds'],'List<int>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'workflowId': workflowId,
        'stepOrder': stepOrder,
        'stepName': stepName,
        'isRequired': isRequired,
        'slaLegalValue': slaLegalValue,
        'slaLegalIsByDay': slaLegalIsByDay,
        'slaInternalValue': slaInternalValue,
        'slaInternalIsByDay': slaInternalIsByDay,
        'requireAttachment': requireAttachment,
        'description': description,
        'createdBy': createdBy,
        'departmentIds': JsonConverters.toJson(departmentIds,'List<int>',context!),
        'stepBasisDocumentIds': JsonConverters.toJson(stepBasisDocumentIds,'List<int>',context!),
        'stepAttachedIds': JsonConverters.toJson(stepAttachedIds,'List<int>',context!),
        'mainAssigneeIds': JsonConverters.toJson(mainAssigneeIds,'List<int>',context!)
    };

    getTypeName() => "WorkflowStep";
    TypeContext? context = _ctx;
}

enum CategoryTypes
{
    Department,
    PartyGroup,
    DocGroup,
    DocType,
    IssuingAgency,
    Status,
    Subjects,
    Workflow,
}

class CreateCategoryModel implements IConvertible
{
    String? name;
    String? description;
    CategoryTypes? type;
    bool? isParty;
    // @ignore()
    List<int>? childList;

    CreateCategoryModel({this.name,this.description,this.type,this.isParty,this.childList});
    CreateCategoryModel.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        description = json['description'];
        type = JsonConverters.fromJson(json['type'],'CategoryTypes',context!);
        isParty = json['isParty'];
        childList = JsonConverters.fromJson(json['childList'],'List<int>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'description': description,
        'type': JsonConverters.toJson(type,'CategoryTypes',context!),
        'isParty': isParty,
        'childList': JsonConverters.toJson(childList,'List<int>',context!)
    };

    getTypeName() => "CreateCategoryModel";
    TypeContext? context = _ctx;
}

class Category extends CreateCategoryModel implements IConvertible
{
    int? id;
    int? level;
    int? sortOrder;
    DateTime? lastUpdate;
    // @ignore()
    List<Category>? children;

    Category({this.id,this.level,this.sortOrder,this.lastUpdate,this.children});
    Category.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        level = json['level'];
        sortOrder = json['sortOrder'];
        lastUpdate = JsonConverters.fromJson(json['lastUpdate'],'DateTime',context!);
        children = JsonConverters.fromJson(json['children'],'List<Category>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'level': level,
        'sortOrder': sortOrder,
        'lastUpdate': JsonConverters.toJson(lastUpdate,'DateTime',context!),
        'children': JsonConverters.toJson(children,'List<Category>',context!)
    });

    getTypeName() => "Category";
    TypeContext? context = _ctx;
}

class SimpleDocumentRelation implements IConvertible
{
    int? id;
    String? title;
    String? documentCode;
    DateTime? publicationDate;

    SimpleDocumentRelation({this.id,this.title,this.documentCode,this.publicationDate});
    SimpleDocumentRelation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        title = json['title'];
        documentCode = json['documentCode'];
        publicationDate = JsonConverters.fromJson(json['publicationDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'title': title,
        'documentCode': documentCode,
        'publicationDate': JsonConverters.toJson(publicationDate,'DateTime',context!)
    };

    getTypeName() => "SimpleDocumentRelation";
    TypeContext? context = _ctx;
}

class WorkFlowProfile implements IConvertible
{
    int? id;
    String? fullName;
    String? email;
    int? departmentId;
    String? avatar;
    String? telephone;
    DateTime? birthday;
    int? confirmStatus;

    WorkFlowProfile({this.id,this.fullName,this.email,this.departmentId,this.avatar,this.telephone,this.birthday,this.confirmStatus});
    WorkFlowProfile.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        fullName = json['fullName'];
        email = json['email'];
        departmentId = json['departmentId'];
        avatar = json['avatar'];
        telephone = json['telephone'];
        birthday = JsonConverters.fromJson(json['birthday'],'DateTime',context!);
        confirmStatus = json['confirmStatus'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'fullName': fullName,
        'email': email,
        'departmentId': departmentId,
        'avatar': avatar,
        'telephone': telephone,
        'birthday': JsonConverters.toJson(birthday,'DateTime',context!),
        'confirmStatus': confirmStatus
    };

    getTypeName() => "WorkFlowProfile";
    TypeContext? context = _ctx;
}

class BasicUploadedFile implements IConvertible
{
    String? fileName;
    String? filekey;
    String? fileUrl;
    String? checksum;
    String? eTag;
    int? fileSize;

    BasicUploadedFile({this.fileName,this.filekey,this.fileUrl,this.checksum,this.eTag,this.fileSize});
    BasicUploadedFile.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fileName = json['fileName'];
        filekey = json['filekey'];
        fileUrl = json['fileUrl'];
        checksum = json['checksum'];
        eTag = json['eTag'];
        fileSize = json['fileSize'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fileName': fileName,
        'filekey': filekey,
        'fileUrl': fileUrl,
        'checksum': checksum,
        'eTag': eTag,
        'fileSize': fileSize
    };

    getTypeName() => "BasicUploadedFile";
    TypeContext? context = _ctx;
}

enum AccessType
{
    Public,
    Restricted,
}

class UploadedFileModel extends BasicUploadedFile implements IConvertible
{
    int? id;
    AccessType? accessType;
    int? createdBy;
    DateTime? createdDate;

    UploadedFileModel({this.id,this.accessType,this.createdBy,this.createdDate});
    UploadedFileModel.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        accessType = JsonConverters.fromJson(json['accessType'],'AccessType',context!);
        createdBy = json['createdBy'];
        createdDate = JsonConverters.fromJson(json['createdDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'accessType': JsonConverters.toJson(accessType,'AccessType',context!),
        'createdBy': createdBy,
        'createdDate': JsonConverters.toJson(createdDate,'DateTime',context!)
    });

    getTypeName() => "UploadedFileModel";
    TypeContext? context = _ctx;
}

class UploadedFileAttach extends UploadedFileModel implements IConvertible
{
    String? fileType;
    int? subDocumentId;
    int? stepId;

    UploadedFileAttach({this.fileType,this.subDocumentId,this.stepId});
    UploadedFileAttach.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        fileType = json['fileType'];
        subDocumentId = json['subDocumentId'];
        stepId = json['stepId'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'fileType': fileType,
        'subDocumentId': subDocumentId,
        'stepId': stepId
    });

    getTypeName() => "UploadedFileAttach";
    TypeContext? context = _ctx;
}

class WorkflowStepDetail extends WorkflowStep implements IConvertible
{
    List<Category>? departments;
    List<SimpleDocumentRelation>? basisDocuments;
    List<SimpleDocumentRelation>? attachedDocuments;
    List<SimpleDocumentRelation>? referenceDocuments;
    List<WorkFlowProfile>? mainAssignees;
    List<UploadedFileAttach>? attachFiles;

    WorkflowStepDetail({this.departments,this.basisDocuments,this.attachedDocuments,this.referenceDocuments,this.mainAssignees,this.attachFiles});
    WorkflowStepDetail.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        departments = JsonConverters.fromJson(json['departments'],'List<Category>',context!);
        basisDocuments = JsonConverters.fromJson(json['basisDocuments'],'List<SimpleDocumentRelation>',context!);
        attachedDocuments = JsonConverters.fromJson(json['attachedDocuments'],'List<SimpleDocumentRelation>',context!);
        referenceDocuments = JsonConverters.fromJson(json['referenceDocuments'],'List<SimpleDocumentRelation>',context!);
        mainAssignees = JsonConverters.fromJson(json['mainAssignees'],'List<WorkFlowProfile>',context!);
        attachFiles = JsonConverters.fromJson(json['attachFiles'],'List<UploadedFileAttach>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'departments': JsonConverters.toJson(departments,'List<Category>',context!),
        'basisDocuments': JsonConverters.toJson(basisDocuments,'List<SimpleDocumentRelation>',context!),
        'attachedDocuments': JsonConverters.toJson(attachedDocuments,'List<SimpleDocumentRelation>',context!),
        'referenceDocuments': JsonConverters.toJson(referenceDocuments,'List<SimpleDocumentRelation>',context!),
        'mainAssignees': JsonConverters.toJson(mainAssignees,'List<WorkFlowProfile>',context!),
        'attachFiles': JsonConverters.toJson(attachFiles,'List<UploadedFileAttach>',context!)
    });

    getTypeName() => "WorkflowStepDetail";
    TypeContext? context = _ctx;
}

class GetWorkflowStepResponse implements IResponseRequest, IConvertible
{
    int? code;
    String? message;
    List<WorkflowStepDetail>? data;

    GetWorkflowStepResponse({this.code,this.message,this.data});
    GetWorkflowStepResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        message = json['message'];
        data = JsonConverters.fromJson(json['data'],'List<WorkflowStepDetail>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'message': message,
        'data': JsonConverters.toJson(data,'List<WorkflowStepDetail>',context!)
    };

    getTypeName() => "GetWorkflowStepResponse";
    TypeContext? context = _ctx;
}

class GetWorkflowStepRequest implements IConvertible
{
    int? workflowId;

    GetWorkflowStepRequest({this.workflowId});
    GetWorkflowStepRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        workflowId = json['workflowId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'workflowId': workflowId
    };

    getTypeName() => "GetWorkflowStepRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'etc_api.vsmlab.vn', types: <String, TypeInfo> {
    'WorkflowStep': TypeInfo(TypeOf.Class, create:() => WorkflowStep()),
    'CategoryTypes': TypeInfo(TypeOf.Enum, enumValues:CategoryTypes.values),
    'CreateCategoryModel': TypeInfo(TypeOf.Class, create:() => CreateCategoryModel()),
    'Category': TypeInfo(TypeOf.Class, create:() => Category()),
    'List<Category>': TypeInfo(TypeOf.Class, create:() => <Category>[]),
    'SimpleDocumentRelation': TypeInfo(TypeOf.Class, create:() => SimpleDocumentRelation()),
    'WorkFlowProfile': TypeInfo(TypeOf.Class, create:() => WorkFlowProfile()),
    'BasicUploadedFile': TypeInfo(TypeOf.Class, create:() => BasicUploadedFile()),
    'AccessType': TypeInfo(TypeOf.Enum, enumValues:AccessType.values),
    'UploadedFileModel': TypeInfo(TypeOf.Class, create:() => UploadedFileModel()),
    'UploadedFileAttach': TypeInfo(TypeOf.Class, create:() => UploadedFileAttach()),
    'WorkflowStepDetail': TypeInfo(TypeOf.Class, create:() => WorkflowStepDetail()),
    'List<SimpleDocumentRelation>': TypeInfo(TypeOf.Class, create:() => <SimpleDocumentRelation>[]),
    'List<WorkFlowProfile>': TypeInfo(TypeOf.Class, create:() => <WorkFlowProfile>[]),
    'List<UploadedFileAttach>': TypeInfo(TypeOf.Class, create:() => <UploadedFileAttach>[]),
    'GetWorkflowStepResponse': TypeInfo(TypeOf.Class, create:() => GetWorkflowStepResponse()),
    'List<WorkflowStepDetail>': TypeInfo(TypeOf.Class, create:() => <WorkflowStepDetail>[]),
    'GetWorkflowStepRequest': TypeInfo(TypeOf.Class, create:() => GetWorkflowStepRequest()),
});

Dart GetWorkflowStepRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

GET /WorkflowStep/by-workflow HTTP/1.1 
Host: etc-api.vsmlab.vn 
Accept: application/xml
HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<GetWorkflowStepResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/tvpl.api.ServiceModel">
  <Code>0</Code>
  <Data xmlns:d2p1="http://schemas.datacontract.org/2004/07/tvpl.data.Models">
    <d2p1:WorkflowStepDetail>
      <d2p1:CreatedAt>0001-01-01T00:00:00</d2p1:CreatedAt>
      <d2p1:CreatedBy>0</d2p1:CreatedBy>
      <d2p1:DeletedAt>0001-01-01T00:00:00</d2p1:DeletedAt>
      <d2p1:DeletedBy>0</d2p1:DeletedBy>
      <d2p1:DepartmentIds xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:int>0</d4p1:int>
      </d2p1:DepartmentIds>
      <d2p1:Description>String</d2p1:Description>
      <d2p1:Id>0</d2p1:Id>
      <d2p1:IsRequired>false</d2p1:IsRequired>
      <d2p1:MainAssigneeIds xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:int>0</d4p1:int>
      </d2p1:MainAssigneeIds>
      <d2p1:RequireAttachment>false</d2p1:RequireAttachment>
      <d2p1:SLAInternalIsByDay>false</d2p1:SLAInternalIsByDay>
      <d2p1:SLAInternalValue>0</d2p1:SLAInternalValue>
      <d2p1:SLALegalIsByDay>false</d2p1:SLALegalIsByDay>
      <d2p1:SLALegalValue>0</d2p1:SLALegalValue>
      <d2p1:SLAWarningSentAt>0001-01-01T00:00:00</d2p1:SLAWarningSentAt>
      <d2p1:SLAWarningSentCount>0</d2p1:SLAWarningSentCount>
      <d2p1:StepAttachedIds xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:int>0</d4p1:int>
      </d2p1:StepAttachedIds>
      <d2p1:StepBasisDocumentIds xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:int>0</d4p1:int>
      </d2p1:StepBasisDocumentIds>
      <d2p1:StepName>String</d2p1:StepName>
      <d2p1:StepOrder>0</d2p1:StepOrder>
      <d2p1:UpdatedAt>0001-01-01T00:00:00</d2p1:UpdatedAt>
      <d2p1:UpdatedBy>0</d2p1:UpdatedBy>
      <d2p1:WorkflowId>0</d2p1:WorkflowId>
      <d2p1:AttachFiles>
        <d2p1:UploadedFileAttach>
          <d2p1:Checksum>String</d2p1:Checksum>
          <d2p1:ETag>String</d2p1:ETag>
          <d2p1:FileName>String</d2p1:FileName>
          <d2p1:FileSize>0</d2p1:FileSize>
          <d2p1:FileUrl>String</d2p1:FileUrl>
          <d2p1:Filekey>String</d2p1:Filekey>
          <d2p1:AccessType>Public</d2p1:AccessType>
          <d2p1:CreatedBy>0</d2p1:CreatedBy>
          <d2p1:CreatedDate>0001-01-01T00:00:00</d2p1:CreatedDate>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:FileType>String</d2p1:FileType>
          <d2p1:StepId>0</d2p1:StepId>
          <d2p1:SubDocumentId>0</d2p1:SubDocumentId>
        </d2p1:UploadedFileAttach>
      </d2p1:AttachFiles>
      <d2p1:AttachedDocuments>
        <d2p1:SimpleDocumentRelation>
          <d2p1:DocumentCode>String</d2p1:DocumentCode>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:PublicationDate>0001-01-01T00:00:00</d2p1:PublicationDate>
          <d2p1:Title>String</d2p1:Title>
          <d2p1:Type>String</d2p1:Type>
        </d2p1:SimpleDocumentRelation>
      </d2p1:AttachedDocuments>
      <d2p1:BasisDocuments>
        <d2p1:SimpleDocumentRelation>
          <d2p1:DocumentCode>String</d2p1:DocumentCode>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:PublicationDate>0001-01-01T00:00:00</d2p1:PublicationDate>
          <d2p1:Title>String</d2p1:Title>
          <d2p1:Type>String</d2p1:Type>
        </d2p1:SimpleDocumentRelation>
      </d2p1:BasisDocuments>
      <d2p1:Departments>
        <d2p1:Category>
          <d2p1:ChildList xmlns:d6p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
            <d6p1:int>0</d6p1:int>
          </d2p1:ChildList>
          <d2p1:Description>String</d2p1:Description>
          <d2p1:IsParty>false</d2p1:IsParty>
          <d2p1:Name>String</d2p1:Name>
          <d2p1:Type>Department</d2p1:Type>
          <d2p1:Children>
            <d2p1:Category>
              <d2p1:ChildList xmlns:d8p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
                <d8p1:int>0</d8p1:int>
              </d2p1:ChildList>
              <d2p1:Description>String</d2p1:Description>
              <d2p1:IsParty>false</d2p1:IsParty>
              <d2p1:Name>String</d2p1:Name>
              <d2p1:Type>Department</d2p1:Type>
              <d2p1:Children>
                <d2p1:Category>
                  <d2p1:ChildList xmlns:d10p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
                    <d10p1:int>0</d10p1:int>
                  </d2p1:ChildList>
                  <d2p1:Description>String</d2p1:Description>
                  <d2p1:IsParty>false</d2p1:IsParty>
                  <d2p1:Name>String</d2p1:Name>
                  <d2p1:Type>Department</d2p1:Type>
                  <d2p1:Children i:nil="true" />
                  <d2p1:CreatedAt>0001-01-01T00:00:00</d2p1:CreatedAt>
                  <d2p1:CreatedBy>0</d2p1:CreatedBy>
                  <d2p1:DeletedAt>0001-01-01T00:00:00</d2p1:DeletedAt>
                  <d2p1:DeletedBy>0</d2p1:DeletedBy>
                  <d2p1:Id>0</d2p1:Id>
                  <d2p1:IsDeleted>false</d2p1:IsDeleted>
                  <d2p1:LastUpdate>0001-01-01T00:00:00</d2p1:LastUpdate>
                  <d2p1:LastUpdateBy>0</d2p1:LastUpdateBy>
                  <d2p1:Level>0</d2p1:Level>
                  <d2p1:SortOrder>0</d2p1:SortOrder>
                </d2p1:Category>
              </d2p1:Children>
              <d2p1:CreatedAt>0001-01-01T00:00:00</d2p1:CreatedAt>
              <d2p1:CreatedBy>0</d2p1:CreatedBy>
              <d2p1:DeletedAt>0001-01-01T00:00:00</d2p1:DeletedAt>
              <d2p1:DeletedBy>0</d2p1:DeletedBy>
              <d2p1:Id>0</d2p1:Id>
              <d2p1:IsDeleted>false</d2p1:IsDeleted>
              <d2p1:LastUpdate>0001-01-01T00:00:00</d2p1:LastUpdate>
              <d2p1:LastUpdateBy>0</d2p1:LastUpdateBy>
              <d2p1:Level>0</d2p1:Level>
              <d2p1:SortOrder>0</d2p1:SortOrder>
            </d2p1:Category>
          </d2p1:Children>
          <d2p1:CreatedAt>0001-01-01T00:00:00</d2p1:CreatedAt>
          <d2p1:CreatedBy>0</d2p1:CreatedBy>
          <d2p1:DeletedAt>0001-01-01T00:00:00</d2p1:DeletedAt>
          <d2p1:DeletedBy>0</d2p1:DeletedBy>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:IsDeleted>false</d2p1:IsDeleted>
          <d2p1:LastUpdate>0001-01-01T00:00:00</d2p1:LastUpdate>
          <d2p1:LastUpdateBy>0</d2p1:LastUpdateBy>
          <d2p1:Level>0</d2p1:Level>
          <d2p1:SortOrder>0</d2p1:SortOrder>
        </d2p1:Category>
      </d2p1:Departments>
      <d2p1:MainAssignees>
        <d2p1:WorkFlowProfile>
          <d2p1:Avatar>String</d2p1:Avatar>
          <d2p1:Birthday>0001-01-01T00:00:00</d2p1:Birthday>
          <d2p1:ConfirmStatus>0</d2p1:ConfirmStatus>
          <d2p1:DepartmentId>0</d2p1:DepartmentId>
          <d2p1:Email>String</d2p1:Email>
          <d2p1:FullName>String</d2p1:FullName>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:Telephone>String</d2p1:Telephone>
        </d2p1:WorkFlowProfile>
      </d2p1:MainAssignees>
      <d2p1:ReferenceDocuments>
        <d2p1:SimpleDocumentRelation>
          <d2p1:DocumentCode>String</d2p1:DocumentCode>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:PublicationDate>0001-01-01T00:00:00</d2p1:PublicationDate>
          <d2p1:Title>String</d2p1:Title>
          <d2p1:Type>String</d2p1:Type>
        </d2p1:SimpleDocumentRelation>
      </d2p1:ReferenceDocuments>
    </d2p1:WorkflowStepDetail>
  </Data>
  <Message>String</Message>
</GetWorkflowStepResponse>