From d40525a0890891c9cf600b66c165b594021e0a96 Mon Sep 17 00:00:00 2001 From: Sergey Luzyanin Date: Wed, 2 Nov 2022 18:47:56 +0300 Subject: [PATCH] oform format --- configs/word.json | 5 +- oform/Field.js | 390 ++++++++++++++++++++++++++++++++++++++++++++++ oform/Main.js | 321 ++++++++++++++++++++++++++++++++++++++ oform/User.js | 306 ++++++++++++++++++++++++++++++++++++ 4 files changed, 1021 insertions(+), 1 deletion(-) create mode 100644 oform/Field.js create mode 100644 oform/Main.js create mode 100644 oform/User.js diff --git a/configs/word.json b/configs/word.json index 40318ab..483536e 100644 --- a/configs/word.json +++ b/configs/word.json @@ -5,7 +5,10 @@ "apiPlugins.js" ], "common": [ - "apiBuilder.js" + "apiBuilder.js", + "oform/Main.js", + "oform/Field.js", + "oform/User.js" ] } } diff --git a/oform/Field.js b/oform/Field.js new file mode 100644 index 0000000..23e460a --- /dev/null +++ b/oform/Field.js @@ -0,0 +1,390 @@ +/* + * (c) Copyright Ascensio System SIA 2010-2019 + * + * This program is a free software product. You can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License (AGPL) + * version 3 as published by the Free Software Foundation. In accordance with + * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect + * that Ascensio System SIA expressly excludes the warranty of non-infringement + * of any third-party rights. + * + * This program is distributed WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For + * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html + * + * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha + * street, Riga, Latvia, EU, LV-1050. + * + * The interactive user interfaces in modified source and object code versions + * of the Program must display Appropriate Legal Notices, as required under + * Section 5 of the GNU AGPL version 3. + * + * Pursuant to Section 7(b) of the License you must retain the original Product + * logo when distributing the program. Pursuant to Section 7(e) we decline to + * grant you any rights under trademark law for use of our trademarks. + * + * All the Product's GUI elements, including illustrations and icon sets, as + * well as technical writing content are licensed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International. See the License + * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode + * + */ + +"use strict"; + +(function(window, undefined) { + + const CBaseFormatObject = AscFormat.CBaseFormatObject; + const InitClass = AscFormat.InitClass; + const CChangesString = AscDFH.CChangesDrawingsString; + const CChangesObject = AscDFH.CChangesDrawingsObject; + const CChangesContent = AscDFH.CChangesDrawingsContent; + + AscDFH.changesFactory[AscDFH.histotyitem_FormFieldMaster_FieldId] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FormFieldMaster_User] = CChangesContent; + AscDFH.changesFactory[AscDFH.histotyitem_FormFieldMaster_Field] = CChangesObject; + AscDFH.changesFactory[AscDFH.histotyitem_FormFieldMaster_SignRequest] = CChangesObject; + AscDFH.changesFactory[AscDFH.histotyitem_FormField_FieldData] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FormField_Body] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FormField_EncryptedData] = CChangesContent; + AscDFH.changesFactory[AscDFH.histotyitem_FormField_FieldMaster] = CChangesObject; + AscDFH.changesFactory[AscDFH.histotyitem_SignRequest_User] = CChangesContent; + AscDFH.changesFactory[AscDFH.histotyitem_EncryptedData_Method] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_EncryptedData_Value] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_EncryptedData_KeyInfo] = CChangesObject; + AscDFH.changesFactory[AscDFH.histotyitem_KeyInfo_User] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_KeyInfo_Value] = CChangesObject; + + + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormFieldMaster_FieldId] = function(oClass, value) {oClass.FieldId = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormFieldMaster_Field] = function(oClass, value) {oClass.Field = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormFieldMaster_SignRequest] = function(oClass, value) {oClass.SignRequest = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormField_FieldData] = function(oClass, value) {oClass.FieldData = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormField_Body] = function(oClass, value) {oClass.Body = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormField_FieldMaster] = function(oClass, value) {oClass.FieldMaster = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_EncryptedData_Method] = function(oClass, value) {oClass.EncryptedMethod = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_EncryptedData_Value] = function(oClass, value) {oClass.EncryptedValue = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_EncryptedData_KeyInfo] = function(oClass, value) {oClass.KeyInfo = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_KeyInfo_User] = function(oClass, value) {oClass.FieldId = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_KeyInfo_Value] = function(oClass, value) {oClass.FieldId = value;}; + + + AscDFH.drawingContentChanges[AscDFH.histotyitem_FormFieldMaster_User] = function (oClass) {return oClass.Users;}; + AscDFH.drawingContentChanges[AscDFH.histotyitem_SignRequest_User] = function (oClass) {return oClass.Users;}; + AscDFH.drawingContentChanges[AscDFH.histotyitem_FormField_EncryptedData] = function (oClass) {return oClass.EndcriptedData;}; + + + function CFieldMaster() { + CBaseFormatObject.call(this); + this.FieldId = null; + this.Users = []; + this.Field = null; + this.SignRequest = null; + } + InitClass(CFieldMaster, CBaseFormatObject, AscDFH.historyitem_type_FormFieldMaster); + CFieldMaster.prototype.setFieldId = function(sFieldId) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FormFieldMaster_FieldId, this.FieldId, sFieldId)); + this.FieldId = sFieldId; + }; + CFieldMaster.prototype.addUser = function(oUser) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_FormFieldMaster_User, this.Users.length, [oUser], true)); + this.Users.push(oUser); + }; + CFieldMaster.prototype.setField = function(oField) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_FormFieldMaster_Field, this.Field, oField)); + this.Field = oField; + if(oField) { + oField.setFieldMaster(this); + } + }; + CFieldMaster.prototype.setSignRequest = function(oSignRequest) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_FormFieldMaster_SignRequest, this.SignRequest, oSignRequest)); + this.SignRequest = oSignRequest; + }; + CFieldMaster.prototype.readAttrXml = function(name, reader) { + switch (name) { + case "id": { + this.setFieldId(reader.GetValue()); + break; + } + } + }; + CFieldMaster.prototype.readChildXml = function (name, reader) { + let oThis = this; + switch (name) { + case "Users": { + let oUsersNode = new CT_XmlNode(function (reader, name){ + if(name === "User") { + let oUserNode = new CT_XmlNode(); + oUserNode.fromXml(reader); + let sId = oUserNode.attributes["id"]; + let oRel = reader.rels.getRelationshipById(sId); + reader.context.addFieldMasterRelation(oThis, oRel.targetFullName) + } + return true; + }); + oUsersNode.fromXml(reader); + break; + } + case "SignRequest": { + let oSignRequest = new CSignRequest(); + oSignRequest.fromXml(reader); + this.setSignRequest(oSignRequest); + break; + } + } + }; + CFieldMaster.prototype.toXml = function (writer) { + writer.WriteXmlString(AscCommonWord.g_sXmlHeader); + writer.WriteXmlNodeStart("FieldMaster"); + writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"); + writer.WriteXmlNullableAttributeString("id", this.FieldId); + writer.WriteXmlAttributesEnd(); + + writer.WriteXmlNodeStart("Users"); + writer.WriteXmlAttributesEnd(); + let oContext = writer.context; + let oUserMasterPartMap = oContext.userMasterPartMap; + let oUsersIdMap = {}; + for(let nUser = 0; nUser < this.Users.length; ++nUser) { + let oUser = this.Users[nUser]; + let oPart = oUserMasterPartMap[oUser.Id]; + if(!oPart) { + oPart = writer.context.part.addPart(AscCommon.openXml.Types.userMaster); + let oUserMemory = new AscCommon.CMemory(); + oUserMemory.context = writer.context; + oPart.part.setDataXml(oUser, oUserMemory); + oUserMasterPartMap[oUser.Id] = oPart; + } + let oNode = new CT_XmlNode(); + let sRId = oContext.part.addRelationship(AscCommon.openXml.Types.userMaster.relationType, oPart.uri); + oNode.attributes["r:id"] = sRId + oUsersIdMap[oUser.Id] = sRId; + oNode.toXml(writer, "User"); + + } + writer.WriteXmlNodeEnd("Users"); + if(this.SignRequest) { + this.SignRequest.toXml(writer, oUsersIdMap); + } + writer.WriteXmlNodeEnd("FieldMaster"); + if(this.Field) { + let oPart = writer.context.docPart.part.addPartWithoutRels(AscCommon.openXml.Types.field); + let oMemory = new AscCommon.CMemory(); + oMemory.context = writer.context; + oPart.setDataXml(this.Field, oMemory); + oMemory.Seek(0); + oPart.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oContext.part.uri) + } + }; + + function CSignRequest() { + CBaseFormatObject.call(this); + this.Users = []; + } + InitClass(CSignRequest, CBaseFormatObject, AscDFH.historyitem_type_SignRequest); + CSignRequest.prototype.addUser = function(oUser) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_SignRequest_User, this.Users.length, [oUser], true)); + this.Users.push(oUser); + }; + CSignRequest.prototype.readChildXml = function (name, reader) { + CFieldMaster.prototype.readChildXml.call(this, name, reader); + }; + CSignRequest.prototype.toXml = function (writer, oUsersIdMap) { + writer.WriteXmlNodeStart("SignRequest"); + writer.WriteXmlAttributesEnd(); + + writer.WriteXmlNodeStart("Users"); + writer.WriteXmlAttributesEnd(); + for(let nUser = 0; nUser < this.Users.length; ++nUser) { + let oUser = this.Users[nUser]; + let oNode = new CT_XmlNode(); + let sRId = oUsersIdMap[oUser.Id]; + if(sRId) { + oNode.attributes["r:id"] = sRId + oUsersIdMap[oUser.Id] = sRId; + oNode.toXml(writer, "User"); + } + + } + writer.WriteXmlNodeEnd("Users"); + writer.WriteXmlNodeEnd("SignRequest"); + }; + function CField() { + CBaseFormatObject.call(this); + this.FieldData = null; + this.EndcriptedData = []; + this.Body = null; + } + InitClass(CField, CBaseFormatObject, AscDFH.historyitem_type_FormField); + CField.prototype.setFieldData = function(oFieldData) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FormField_FieldData, this.FieldData, oFieldData)); + this.FieldData = oFieldData; + }; + CField.prototype.setBody = function(sBody) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FormField_Body, this.Body, sBody)); + this.Body = sBody; + }; + CField.prototype.addEncryptedData = function(oEncryptedData) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_FormField_EncryptedData, this.EndcriptedData.length, [oEncryptedData], true)); + this.EndcriptedData.push(oEncryptedData); + }; + CField.prototype.setFieldMaster = function(oFieldMaster) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_FormField_FieldMaster, this.FieldMaster, oFieldMaster)); + this.FieldMaster = oFieldMaster; + }; + CField.prototype.readChildXml = function (name, reader) { + switch (name) { + case "FieldData": { + let oFieldData = new AscCommon.CDocPart(this); + oFieldData.fromXml(reader); + this.setFieldData(oFieldData); + break; + } + case "EncryptedData": { + let oEncryptedData = new CEncryptedData(); + oEncryptedData.fromXml(reader); + this.addEncryptedData(oEncryptedData); + break; + } + case "Body": { + let oBodyNode = new CT_XmlNode(); + oBodyNode.fromXml(reader); + this.setBody(oBodyNode.text); + break; + } + } + }; + CField.prototype.toXml = function(writer) { + writer.WriteXmlString(AscCommonWord.g_sXmlHeader); + writer.WriteXmlNodeStart("Field"); + writer.WriteXmlAttributesEnd(); + if(this.Body) { + let oNode = new CT_XmlNode(); + oNode.text = this.Body; + oNode.toXml(writer, "Body"); + } + if(this.FieldData) { + this.FieldData.toXml(writer, "FieldData"); + } + for(let nData = 0; nData < this.EndcriptedData.length; ++nData) { + this.EndcriptedData[nData].toXml(writer); + } + writer.WriteXmlNodeEnd("Field"); + }; + + function CEncryptedData() { + CBaseFormatObject.call(this); + this.EncryptedMethod = null; + this.EncryptedValue = null; + this.KeyInfo = null; + } + InitClass(CEncryptedData, CBaseFormatObject, AscDFH.historyitem_type_EncryptedData); + CEncryptedData.prototype.setEncryptedMethod = function (sEncryptedMethod) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_EncryptedData_Method, this.EncryptedMethod, sEncryptedMethod)); + this.EncryptedMethod = sEncryptedMethod; + }; + CEncryptedData.prototype.setEncryptedValue = function (sEncryptedValue) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_EncryptedData_Value, this.EncryptedValue, sEncryptedValue)); + this.EncryptedValue = sEncryptedValue; + }; + CEncryptedData.prototype.setKeyInfo = function (oKeyInfo) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_EncryptedData_KeyInfo, this.KeyInfo, oKeyInfo)); + this.KeyInfo = oKeyInfo; + }; + CEncryptedData.prototype.readChildXml = function (name, reader) { + switch (name) { + case "EncryptedMethod": { + let oMethod = new CT_XmlNode(); + oMethod.fromXml(reader); + let sAlgorithm = oMethod.attributes["Algorithm"]; + if(sAlgorithm) { + this.setEncryptedMethod(sAlgorithm) + } + break; + } + case "EncryptedValue": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setEncryptedValue(oNode.text); + break; + } + case "KeyInfo": { + let oKeyInfo = new CKeyInfo(); + oKeyInfo.fromXml(reader); + this.setKeyInfo(oKeyInfo) + break; + } + } + }; + CEncryptedData.prototype.toXml = function(writer) { + writer.WriteXmlNodeStart("EncryptedData"); + writer.WriteXmlAttributesEnd(); + if(this.EncryptedMethod) { + let oMethod = new CT_XmlNode(); + oMethod.attributes["Algorithm"] = this.EncryptedMethod; + oMethod.toXml(writer, "EncryptedMethod"); + } + if(this.EncryptedValue) { + let oValue = new CT_XmlNode(); + oValue.text = this.EncryptedValue; + oValue.toXml(writer, "EncryptedValue"); + } + if(this.KeyInfo) { + this.KeyInfo.toXml(writer); + } + writer.WriteXmlNodeEnd("EncryptedData"); + }; + + function CKeyInfo() { + CBaseFormatObject.call(this); + this.UserId = null; + this.Value = null; + } + InitClass(CKeyInfo, CBaseFormatObject, AscDFH.historyitem_type_KeyInfo); + CKeyInfo.prototype.setUserId = function (sUserId) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_KeyInfo_User, this.UserId, sUserId)); + this.UserId = sUserId; + }; + CKeyInfo.prototype.setValue = function (sValue) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_KeyInfo_Value, this.Value, sValue)); + this.Value = sValue; + }; + CKeyInfo.prototype.readChildXml = function (name, reader) { + switch (name) { + case "User": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setUserId(oNode.attributes["id"]); + break; + } + case "Value": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setValue(oNode.text); + break; + } + } + }; + CKeyInfo.prototype.toXml = function(writer) { + writer.WriteXmlNodeStart("KeyInfo"); + writer.WriteXmlAttributesEnd(); + if(this.UserId) { + let oNode = new CT_XmlNode(); + oNode.attributes["id"] = this.UserId; + oNode.toXml(writer, "User"); + } + if(this.Value) { + let oValue = new CT_XmlNode(); + oValue.text = this.Value; + oValue.toXml(writer, "Value"); + } + writer.WriteXmlNodeEnd("KeyInfo"); + }; + + AscWord.CFieldMaster = CFieldMaster; + AscWord.CField = CField; + AscWord.CEncryptedData = CEncryptedData; + AscWord.CKeyInfo = CKeyInfo; + AscWord.CSignRequest = CSignRequest; +})(window); diff --git a/oform/Main.js b/oform/Main.js new file mode 100644 index 0000000..916e7af --- /dev/null +++ b/oform/Main.js @@ -0,0 +1,321 @@ +/* + * (c) Copyright Ascensio System SIA 2010-2019 + * + * This program is a free software product. You can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License (AGPL) + * version 3 as published by the Free Software Foundation. In accordance with + * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect + * that Ascensio System SIA expressly excludes the warranty of non-infringement + * of any third-party rights. + * + * This program is distributed WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For + * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html + * + * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha + * street, Riga, Latvia, EU, LV-1050. + * + * The interactive user interfaces in modified source and object code versions + * of the Program must display Appropriate Legal Notices, as required under + * Section 5 of the GNU AGPL version 3. + * + * Pursuant to Section 7(b) of the License you must retain the original Product + * logo when distributing the program. Pursuant to Section 7(e) we decline to + * grant you any rights under trademark law for use of our trademarks. + * + * All the Product's GUI elements, including illustrations and icon sets, as + * well as technical writing content are licensed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International. See the License + * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode + * + */ + +"use strict"; + +(function(window, undefined) { + + const CBaseFormatObject = AscFormat.CBaseFormatObject; + const InitClass = AscFormat.InitClass; + const CChangesString = AscDFH.CChangesDrawingsString; + const CChangesObject = AscDFH.CChangesDrawingsObject; + const CChangesContent = AscDFH.CChangesDrawingsContent; + const CChangesLong = AscDFH.CChangesDrawingsLong; + + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_Author] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_Date] = CChangesObject; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_Description] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_Type] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_Application] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_DocumentId] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_FieldsGroups] = CChangesContent; + AscDFH.changesFactory[AscDFH.histotyitem_MainDocument_User] = CChangesContent; + AscDFH.changesFactory[AscDFH.histotyitem_FormDate_Format] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FormDate_Value] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FieldsGroup_Id] = CChangesString; + AscDFH.changesFactory[AscDFH.histotyitem_FieldsGroup_Weight] = CChangesLong; + AscDFH.changesFactory[AscDFH.histotyitem_FieldsGroup_Field] = CChangesContent; + + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_Author] = function (oClass, value) {oClass.Author = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_Date] = function (oClass, value) {oClass.Date = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_Description] = function (oClass, value) {oClass.Description = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_Type] = function (oClass, value) {oClass.Type = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_Application] = function (oClass, value) {oClass.Application = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_MainDocument_DocumentId] = function (oClass, value) {oClass.DocumentId = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormDate_Format] = function (oClass, value) {oClass.Format = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FormDate_Value] = function (oClass, value) {oClass.Value = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FieldsGroup_Id] = function (oClass, value) {oClass.GroupId = value;}; + AscDFH.drawingsChangesMap[AscDFH.histotyitem_FieldsGroup_Weight] = function (oClass, value) {oClass.Weight = value;}; + + AscDFH.drawingContentChanges[AscDFH.histotyitem_MainDocument_FieldsGroups] = function (oClass) {return oClass.FieldsGroups;}; + AscDFH.drawingContentChanges[AscDFH.histotyitem_MainDocument_User] = function (oClass) {return oClass.Users;}; + AscDFH.drawingContentChanges[AscDFH.histotyitem_FieldsGroup_Field] = function (oClass) {return oClass.Fields;}; + + + function CMainDocument() { + CBaseFormatObject.call(this); + this.Author = null; + this.Date = null; + this.Description = null; + this.Type = null; + this.Application = null; + this.DocumentId = null; + this.FieldsGroups = []; + + this.Users = []; + } + InitClass(CMainDocument, CBaseFormatObject, AscDFH.historyitem_type_MainDocument); + CMainDocument.prototype.setAuthor = function (sAuthor) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_MainDocument_Author, this.Author, sAuthor)); + this.Author = sAuthor; + }; + CMainDocument.prototype.setDate = function (oDate) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.histotyitem_MainDocument_Date, this.Date, oDate)); + this.Date = oDate; + }; + CMainDocument.prototype.setDescription = function (sDescription) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_MainDocument_Description, this.Description, sDescription)); + this.Description = sDescription; + }; + CMainDocument.prototype.setType = function (sType) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_MainDocument_Type, this.Type, sType)); + this.Type = sType; + }; + CMainDocument.prototype.setApplication = function (sApplication) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_MainDocument_Application, this.Application, sApplication)); + this.Application = sApplication; + }; + CMainDocument.prototype.setDocumentId = function (sDocumentId) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_MainDocument_DocumentId, this.DocumentId, sDocumentId)); + this.DocumentId = sDocumentId; + }; + CMainDocument.prototype.addFieldsGroups = function(oFieldsGroup) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_MainDocument_FieldsGroups, this.FieldsGroups.length, [oFieldsGroup], true)); + this.FieldsGroups.push(oFieldsGroup); + }; + CMainDocument.prototype.addUser = function(oUser) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_MainDocument_User, this.FieldsGroups.length, [oUser], true)); + this.Users.push(oUser); + }; + CMainDocument.prototype.readChildXml = function (name, reader) { + switch (name) { + case "Author": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + let sAuthor = oNode.attributes["id"]; + if(sAuthor) { + this.setAuthor(sAuthor); + } + break; + } + case "Date": { + let oDate = new CFormDate(); + oDate.fromXml(reader); + this.setDate(oDate); + break; + } + case "Description": { + + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setDescription(oNode.text); + break; + } + case "Type": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setType(oNode.text); + break; + } + case "Application": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setApplication(oNode.text); + break; + } + case "Id": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setDocumentId(oNode.text); + break; + } + case "FieldsGroup": { + let oFieldsGroup = new CFieldsGroup(); + oFieldsGroup.fromXml(reader); + this.addFieldsGroups(oFieldsGroup); + break; + } + } + }; + CMainDocument.prototype.toXml = function(writer) { + + writer.WriteXmlString(AscCommonWord.g_sXmlHeader); + writer.WriteXmlNodeStart("Document"); + writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"); + writer.WriteXmlAttributesEnd(); + if(this.Author) { + let oNode = new CT_XmlNode(); + oNode.attributes["id"] = this.Author; + oNode.toXml(writer, "Author"); + } + if(this.Date) { + this.Date.toXml(writer); + } + let oDescriptionNode = new CT_XmlNode(); + oDescriptionNode.text = this.Description; + oDescriptionNode.toXml(writer, "Description"); + + let oTypeNode = new CT_XmlNode(); + oTypeNode.text = this.Type; + oTypeNode.toXml(writer, "Type"); + + let oAppNode = new CT_XmlNode(); + oAppNode.text = this.Application; + oAppNode.toXml(writer, "Application"); + + let oIdNode = new CT_XmlNode(); + oIdNode.text = this.DocumentId; + oIdNode.toXml(writer, "Id"); + for(let nFG = 0; nFG < this.FieldsGroups.length; ++nFG) { + this.FieldsGroups[nFG].toXml(writer); + } + writer.WriteXmlNodeEnd("Document"); + }; + + function CFormDate() { + CBaseFormatObject.call(this); + this.Format = null; + this.Value = null; + } + InitClass(CFormDate, CBaseFormatObject, AscDFH.historyitem_type_FormDate); + CFormDate.prototype.setFormat = function(sFormat) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FormDate_Format, this.Format, sFormat)); + this.Format = sFormat; + }; + CFormDate.prototype.setValue = function(sValue) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FormDate_Value, this.Value, sValue)); + this.Value = sValue; + }; + CFormDate.prototype.readChildXml = function (name, reader) { + switch (name) { + case "Format": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setFormat(oNode.text); + break; + } + case "Value": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setValue(oNode.text); + break; + } + } + }; + CFormDate.prototype.toXml = function (writer) { + writer.WriteXmlNodeStart("Date"); + writer.WriteXmlAttributesEnd(); + + let oFormatNode = new CT_XmlNode(); + oFormatNode.text = this.Format; + oFormatNode.toXml(writer, "Format"); + + let oValueNode = new CT_XmlNode(); + oValueNode.text = this.Value; + oValueNode.toXml(writer, "Value"); + + writer.WriteXmlNodeEnd("Date"); + }; + + function CFieldsGroup() { + CBaseFormatObject.call(this); + this.GroupId = null; + this.Weight = null; + this.Fields = []; + } + InitClass(CFieldsGroup, CBaseFormatObject, AscDFH.historyitem_type_FieldsGroup); + CFieldsGroup.prototype.setGroupId = function (sGroupId) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_FieldsGroup_Id, this.GroupId, sGroupId)); + this.GroupId = sGroupId; + }; + CFieldsGroup.prototype.setWeight = function (nWeight) { + AscCommon.History.Add(new CChangesLong(this, AscDFH.histotyitem_FieldsGroup_Weight, this.Weight, nWeight)); + this.Weight = nWeight; + }; + CFieldsGroup.prototype.addField = function (oField) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.histotyitem_FieldsGroup_Field, this.Fields.length, [oField], true)); + this.Fields.push(oField); + }; + CFieldsGroup.prototype.readAttrXml = function(name, reader) { + switch (name) { + case "id": { + this.setGroupId(reader.GetValue()); + break; + } + case "weight": { + this.setWeight(reader.GetValueInt()); + break; + } + } + }; + CFieldsGroup.prototype.readChildXml = function(name, reader) { + switch (name) { + case "Field": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + let sId = oNode.attributes["id"]; + let oRel = reader.rels.getRelationshipById(sId); + reader.context.addFieldGroupRelation(this, oRel.targetFullName); + break; + } + } + }; + CFieldsGroup.prototype.toXml = function (writer) { + writer.WriteXmlNodeStart("FieldsGroup"); + writer.WriteXmlNullableAttributeString("id", this.GroupId); + writer.WriteXmlNullableAttributeInt("weight", this.Weight); + writer.WriteXmlAttributesEnd(); + + let oContext = writer.context; + let oFldMasterPartMap = oContext.fieldMastersPartMap; + for(let nFldMaster = 0; nFldMaster < this.Fields.length; ++nFldMaster) { + let oFieldMaster = this.Fields[nFldMaster]; + let oPart = oFldMasterPartMap[oFieldMaster.Id]; + if(!oPart) { + oPart = writer.context.part.addPart(AscCommon.openXml.Types.fieldMaster); + let oFldMemory = new AscCommon.CMemory(); + oFldMemory.context = writer.context; + oPart.part.setDataXml(oFieldMaster, oFldMemory); + oFldMasterPartMap[oFieldMaster.Id] = oPart; + } + let oNode = new CT_XmlNode(); + oNode.attributes["r:id"] = oContext.part.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oPart.part.uri); + oNode.toXml(writer, "Field"); + } + + writer.WriteXmlNodeEnd("FieldsGroup"); + }; + + AscWord.CMainDocument = CMainDocument; + AscWord.CFieldsGroup = CFieldsGroup; + AscWord.CFormDate = CFormDate; +})(window); diff --git a/oform/User.js b/oform/User.js new file mode 100644 index 0000000..644af30 --- /dev/null +++ b/oform/User.js @@ -0,0 +1,306 @@ +/* + * (c) Copyright Ascensio System SIA 2010-2019 + * + * This program is a free software product. You can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License (AGPL) + * version 3 as published by the Free Software Foundation. In accordance with + * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect + * that Ascensio System SIA expressly excludes the warranty of non-infringement + * of any third-party rights. + * + * This program is distributed WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For + * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html + * + * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha + * street, Riga, Latvia, EU, LV-1050. + * + * The interactive user interfaces in modified source and object code versions + * of the Program must display Appropriate Legal Notices, as required under + * Section 5 of the GNU AGPL version 3. + * + * Pursuant to Section 7(b) of the License you must retain the original Product + * logo when distributing the program. Pursuant to Section 7(e) we decline to + * grant you any rights under trademark law for use of our trademarks. + * + * All the Product's GUI elements, including illustrations and icon sets, as + * well as technical writing content are licensed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International. See the License + * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode + * + */ + +"use strict"; + +(function(window, undefined) { + const CBaseFormatObject = AscFormat.CBaseFormatObject; + const InitClass = AscFormat.InitClass; + const CChangesString = AscDFH.CChangesDrawingsString; + const CChangesObject = AscDFH.CChangesDrawingsObject; + const CChangesContent = AscDFH.CChangesDrawingsContent; + + AscDFH.changesFactory[AscDFH.historyitem_UserMasterUserId] = CChangesString; + AscDFH.changesFactory[AscDFH.historyitem_UserMasterSignInfo] = CChangesObject; + AscDFH.changesFactory[AscDFH.historyitem_UserMasterCipherInfo] = CChangesObject; + AscDFH.changesFactory[AscDFH.historyitem_UserMasterRole] = CChangesString; + AscDFH.changesFactory[AscDFH.historyitem_UserEmail] = CChangesString; + AscDFH.changesFactory[AscDFH.historyitem_UserTelephone] = CChangesString; + AscDFH.changesFactory[AscDFH.historyitem_UserMasterUser] = CChangesContent; + + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterUserId] = function(oClass, value) {oClass.UserId = value;}; + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterSignInfo] = function(oClass, value) {oClass.SignInfo = value;}; + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterCipherInfo] = function(oClass, value) {oClass.CipherInfo = value;}; + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterRole] = function(oClass, value) {oClass.Role = value;}; + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserEmail] = function(oClass, value) {oClass.Email = value;}; + AscDFH.drawingsChangesMap[AscDFH.historyitem_UserTelephone] = function(oClass, value) {oClass.Telephone = value;}; + + AscDFH.drawingContentChanges[AscDFH.historyitem_UserMasterUser] = function(oClass) {return oClass.Users;}; + + + + function CUserMaster() { + CBaseFormatObject.call(this); + this.UserId = null; + this.SignInfo = null; + this.CipherInfo = null; + this.Role = null; + + this.Users = []; + } + InitClass(CUserMaster, CBaseFormatObject, AscDFH.historyitem_type_UserMaster); + CUserMaster.prototype.setUserId = function (sUserId) { + AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterUserId, this.UserId, sUserId)); + this.UserId = sUserId; + }; + CUserMaster.prototype.setSignInfo = function (oSignInfo) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterSignInfo, this.SignInfo, oSignInfo)); + this.SignInfo = oSignInfo; + + }; + CUserMaster.prototype.setCipherInfo = function (oCipherInfo) { + AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterCipherInfo, this.CipherInfo, oCipherInfo)); + this.CipherInfo = oCipherInfo; + }; + CUserMaster.prototype.setRole = function (sRole) { + AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterRole, this.Role, sRole)); + this.Role = sRole; + }; + CUserMaster.prototype.addUser = function (oUser) { + AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_UserMasterUser, this.Users.length, [oUser], true)); + this.Users.push(oUser); + }; + CUserMaster.prototype.readChildXml = function (name, reader) { + let bRead = false; + switch (name) { + case "Id": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setUserId(oNode.text); + bRead = true; + break; + } + case "SignInfo": { + let oSignInfo = new CSignInfo(); + oSignInfo.fromXml(reader); + this.setSignInfo(oSignInfo); + bRead = true; + break; + } + case "CipherInfo": { + let oCipherInfo = new CCipherInfo(); + oCipherInfo.fromXml(reader); + this.setCipherInfo(oCipherInfo); + bRead = true; + break; + } + case "Role": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setRole(oNode.text); + bRead = true; + break; + } + } + return bRead; + }; + CUserMaster.prototype.writeChildren = function(writer) { + let oIdNode = new CT_XmlNode(); + oIdNode.text = this.UserId; + oIdNode.toXml(writer, "Id"); + if(this.SignInfo) { + this.SignInfo.toXml(writer); + } + if(this.CipherInfo) { + this.CipherInfo.toXml(writer); + } + let oRoleNode = new CT_XmlNode(); + oRoleNode.text = this.Role; + oRoleNode.toXml(writer, "Role"); + } + CUserMaster.prototype.toXml = function (writer) { + writer.WriteXmlString(AscCommonWord.g_sXmlHeader); + writer.WriteXmlNodeStart("UserMaster"); + writer.WriteXmlAttributesEnd(); + this.writeChildren(writer); + writer.WriteXmlNodeEnd("UserMaster"); + }; + + function CUser() { + CUserMaster.call(this); + this.Email = null; + this.Telephone = null; + } + InitClass(CUser, CUserMaster, AscDFH.historyitem_type_User); + CUser.prototype.setEmail = function (sEmail) { + AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserEmail, this.Email, sEmail)); + this.Email = sEmail; + }; + CUser.prototype.setTelephone = function (sTelephone) { + AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserTelephone, this.Telephone, sTelephone)); + this.Telephone = sTelephone; + }; + CUser.prototype.readChildXml = function (name, reader) { + if(CUserMaster.prototype.readChildXml.call(this, name, reader)) { + return true; + } + let bRead = false; + switch (name) { + case "Email": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setEmail(oNode.text); + bRead = true; + break; + } + case "Telephone": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setTelephone(oNode.text); + bRead = true; + break; + } + } + return bRead; + }; + CUser.prototype.toXml = function (writer) { + writer.WriteXmlString(AscCommonWord.g_sXmlHeader); + writer.WriteXmlNodeStart("User"); + writer.WriteXmlAttributesEnd(); + let oEmailNode = new CT_XmlNode(); + oEmailNode.text = this.Email; + oEmailNode.toXml(writer, "Email"); + + let oTelephoneNode = new CT_XmlNode(); + oTelephoneNode.text = this.Telephone; + oTelephoneNode.toXml(writer, "Telephone"); + this.writeChildren(writer); + writer.WriteXmlNodeEnd("User"); + }; + + function CSignInfo() { + CBaseFormatObject.call(this); + this.PublicKey = null; + this.X509 = null; + this.ImageValid = null; + this.ImageInvalid = null; + } + InitClass(CSignInfo, CBaseFormatObject, AscDFH.historyitem_type_SignInfo); + CSignInfo.prototype.setPublicKey = function (sPublicKey) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_SignInfo_PublicKey, this.PublicKey, sPublicKey)); + this.PublicKey = sPublicKey; + }; + CSignInfo.prototype.setX509 = function (sX509) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_SignInfo_X509, this.X509, sX509)); + this.X509 = sX509; + }; + CSignInfo.prototype.setImageValid = function (sImageValid) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_SignInfo_ImageValid, this.ImageValid, sImageValid)); + this.ImageValid = sImageValid; + }; + CSignInfo.prototype.setImageInvalid = function (sImageInvalid) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_SignInfo_ImageInvalid, this.ImageInvalid, sImageInvalid)); + this.ImageInvalid = sImageInvalid; + }; + CSignInfo.prototype.readChildXml = function (name, reader) { + switch (name) { + case "PublicKey": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setPublicKey(oNode.text); + break; + } + case "X509": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setX509(oNode.text); + break; + } + case "ImageValid": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setImageValid(oNode.text); + break; + } + case "ImageInvalid": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setImageInvalid(oNode.text); + break; + } + } + }; + CSignInfo.prototype.toXml = function(writer) { + writer.WriteXmlNodeStart("SignInfo"); + writer.WriteXmlAttributesEnd(); + let oPublicKeyNode = new CT_XmlNode(); + oPublicKeyNode.text = this.PublicKey; + oPublicKeyNode.toXml(writer, "PublicKey"); + + let oX509Node = new CT_XmlNode(); + oX509Node.text = this.X509; + oX509Node.toXml(writer, "X509"); + + let oImageValidNode = new CT_XmlNode(); + oImageValidNode.text = this.ImageValid; + oImageValidNode.toXml(writer, "ImageValid"); + + let oImageInvalidNode = new CT_XmlNode(); + oImageInvalidNode.text = this.ImageInvalid; + oImageInvalidNode.toXml(writer, "ImageInvalid"); + + writer.WriteXmlNodeEnd("SignInfo"); + }; + + function CCipherInfo() { + CBaseFormatObject.call(this); + this.PublicKey = null; + } + InitClass(CCipherInfo, CBaseFormatObject, AscDFH.historyitem_type_CipherInfo); + CCipherInfo.prototype.setPublicKey = function (sPublicKey) { + AscCommon.History.Add(new CChangesString(this, AscDFH.histotyitem_CipherInfo_PublicKey, this.PublicKey, sPublicKey)); + this.PublicKey = sPublicKey; + }; + CCipherInfo.prototype.readChildXml = function (name, reader) { + switch (name) { + case "PublicKey": { + let oNode = new CT_XmlNode(); + oNode.fromXml(reader); + this.setPublicKey(oNode.text); + break; + } + } + }; + CCipherInfo.prototype.toXml = function(writer) { + writer.WriteXmlNodeStart("CipherInfo"); + writer.WriteXmlAttributesEnd(); + let oPublicKeyNode = new CT_XmlNode(); + oPublicKeyNode.text = this.PublicKey; + oPublicKeyNode.toXml(writer, "PublicKey"); + writer.WriteXmlNodeEnd("CipherInfo"); + }; + + AscWord.CUserMaster = CUserMaster; + AscWord.CUser = CUser; + AscWord.CSignInfo = CSignInfo; + AscWord.CCipherInfo = CCipherInfo; +})(window);