Example #1
0
 public FileSyncBaseFilter(JToken node) : base(node)
 {
     if (node["partnerIdEqual"] != null)
     {
         this._PartnerIdEqual = ParseInt(node["partnerIdEqual"].Value <string>());
     }
     if (node["fileObjectTypeEqual"] != null)
     {
         this._FileObjectTypeEqual = (FileSyncObjectType)StringEnum.Parse(typeof(FileSyncObjectType), node["fileObjectTypeEqual"].Value <string>());
     }
     if (node["fileObjectTypeIn"] != null)
     {
         this._FileObjectTypeIn = node["fileObjectTypeIn"].Value <string>();
     }
     if (node["objectIdEqual"] != null)
     {
         this._ObjectIdEqual = node["objectIdEqual"].Value <string>();
     }
     if (node["objectIdIn"] != null)
     {
         this._ObjectIdIn = node["objectIdIn"].Value <string>();
     }
     if (node["versionEqual"] != null)
     {
         this._VersionEqual = node["versionEqual"].Value <string>();
     }
     if (node["versionIn"] != null)
     {
         this._VersionIn = node["versionIn"].Value <string>();
     }
     if (node["objectSubTypeEqual"] != null)
     {
         this._ObjectSubTypeEqual = ParseInt(node["objectSubTypeEqual"].Value <string>());
     }
     if (node["objectSubTypeIn"] != null)
     {
         this._ObjectSubTypeIn = node["objectSubTypeIn"].Value <string>();
     }
     if (node["dcEqual"] != null)
     {
         this._DcEqual = node["dcEqual"].Value <string>();
     }
     if (node["dcIn"] != null)
     {
         this._DcIn = node["dcIn"].Value <string>();
     }
     if (node["originalEqual"] != null)
     {
         this._OriginalEqual = ParseInt(node["originalEqual"].Value <string>());
     }
     if (node["createdAtGreaterThanOrEqual"] != null)
     {
         this._CreatedAtGreaterThanOrEqual = ParseInt(node["createdAtGreaterThanOrEqual"].Value <string>());
     }
     if (node["createdAtLessThanOrEqual"] != null)
     {
         this._CreatedAtLessThanOrEqual = ParseInt(node["createdAtLessThanOrEqual"].Value <string>());
     }
     if (node["updatedAtGreaterThanOrEqual"] != null)
     {
         this._UpdatedAtGreaterThanOrEqual = ParseInt(node["updatedAtGreaterThanOrEqual"].Value <string>());
     }
     if (node["updatedAtLessThanOrEqual"] != null)
     {
         this._UpdatedAtLessThanOrEqual = ParseInt(node["updatedAtLessThanOrEqual"].Value <string>());
     }
     if (node["readyAtGreaterThanOrEqual"] != null)
     {
         this._ReadyAtGreaterThanOrEqual = ParseInt(node["readyAtGreaterThanOrEqual"].Value <string>());
     }
     if (node["readyAtLessThanOrEqual"] != null)
     {
         this._ReadyAtLessThanOrEqual = ParseInt(node["readyAtLessThanOrEqual"].Value <string>());
     }
     if (node["syncTimeGreaterThanOrEqual"] != null)
     {
         this._SyncTimeGreaterThanOrEqual = ParseInt(node["syncTimeGreaterThanOrEqual"].Value <string>());
     }
     if (node["syncTimeLessThanOrEqual"] != null)
     {
         this._SyncTimeLessThanOrEqual = ParseInt(node["syncTimeLessThanOrEqual"].Value <string>());
     }
     if (node["statusEqual"] != null)
     {
         this._StatusEqual = (FileSyncStatus)ParseEnum(typeof(FileSyncStatus), node["statusEqual"].Value <string>());
     }
     if (node["statusIn"] != null)
     {
         this._StatusIn = node["statusIn"].Value <string>();
     }
     if (node["fileTypeEqual"] != null)
     {
         this._FileTypeEqual = (FileSyncType)ParseEnum(typeof(FileSyncType), node["fileTypeEqual"].Value <string>());
     }
     if (node["fileTypeIn"] != null)
     {
         this._FileTypeIn = node["fileTypeIn"].Value <string>();
     }
     if (node["linkedIdEqual"] != null)
     {
         this._LinkedIdEqual = ParseInt(node["linkedIdEqual"].Value <string>());
     }
     if (node["linkCountGreaterThanOrEqual"] != null)
     {
         this._LinkCountGreaterThanOrEqual = ParseInt(node["linkCountGreaterThanOrEqual"].Value <string>());
     }
     if (node["linkCountLessThanOrEqual"] != null)
     {
         this._LinkCountLessThanOrEqual = ParseInt(node["linkCountLessThanOrEqual"].Value <string>());
     }
     if (node["fileSizeGreaterThanOrEqual"] != null)
     {
         this._FileSizeGreaterThanOrEqual = ParseFloat(node["fileSizeGreaterThanOrEqual"].Value <string>());
     }
     if (node["fileSizeLessThanOrEqual"] != null)
     {
         this._FileSizeLessThanOrEqual = ParseFloat(node["fileSizeLessThanOrEqual"].Value <string>());
     }
 }
Example #2
0
 public FileSync(JToken node) : base(node)
 {
     if (node["id"] != null)
     {
         this._Id = ParseLong(node["id"].Value <string>());
     }
     if (node["partnerId"] != null)
     {
         this._PartnerId = ParseInt(node["partnerId"].Value <string>());
     }
     if (node["fileObjectType"] != null)
     {
         this._FileObjectType = (FileSyncObjectType)StringEnum.Parse(typeof(FileSyncObjectType), node["fileObjectType"].Value <string>());
     }
     if (node["objectId"] != null)
     {
         this._ObjectId = node["objectId"].Value <string>();
     }
     if (node["version"] != null)
     {
         this._Version = node["version"].Value <string>();
     }
     if (node["objectSubType"] != null)
     {
         this._ObjectSubType = ParseInt(node["objectSubType"].Value <string>());
     }
     if (node["dc"] != null)
     {
         this._Dc = node["dc"].Value <string>();
     }
     if (node["original"] != null)
     {
         this._Original = ParseInt(node["original"].Value <string>());
     }
     if (node["createdAt"] != null)
     {
         this._CreatedAt = ParseInt(node["createdAt"].Value <string>());
     }
     if (node["updatedAt"] != null)
     {
         this._UpdatedAt = ParseInt(node["updatedAt"].Value <string>());
     }
     if (node["readyAt"] != null)
     {
         this._ReadyAt = ParseInt(node["readyAt"].Value <string>());
     }
     if (node["syncTime"] != null)
     {
         this._SyncTime = ParseInt(node["syncTime"].Value <string>());
     }
     if (node["status"] != null)
     {
         this._Status = (FileSyncStatus)ParseEnum(typeof(FileSyncStatus), node["status"].Value <string>());
     }
     if (node["fileType"] != null)
     {
         this._FileType = (FileSyncType)ParseEnum(typeof(FileSyncType), node["fileType"].Value <string>());
     }
     if (node["linkedId"] != null)
     {
         this._LinkedId = ParseInt(node["linkedId"].Value <string>());
     }
     if (node["linkCount"] != null)
     {
         this._LinkCount = ParseInt(node["linkCount"].Value <string>());
     }
     if (node["fileRoot"] != null)
     {
         this._FileRoot = node["fileRoot"].Value <string>();
     }
     if (node["filePath"] != null)
     {
         this._FilePath = node["filePath"].Value <string>();
     }
     if (node["fileSize"] != null)
     {
         this._FileSize = ParseFloat(node["fileSize"].Value <string>());
     }
     if (node["fileUrl"] != null)
     {
         this._FileUrl = node["fileUrl"].Value <string>();
     }
     if (node["fileContent"] != null)
     {
         this._FileContent = node["fileContent"].Value <string>();
     }
     if (node["fileDiscSize"] != null)
     {
         this._FileDiscSize = ParseFloat(node["fileDiscSize"].Value <string>());
     }
     if (node["isCurrentDc"] != null)
     {
         this._IsCurrentDc = ParseBool(node["isCurrentDc"].Value <string>());
     }
     if (node["isDir"] != null)
     {
         this._IsDir = ParseBool(node["isDir"].Value <string>());
     }
     if (node["originalId"] != null)
     {
         this._OriginalId = ParseInt(node["originalId"].Value <string>());
     }
     if (node["srcPath"] != null)
     {
         this._SrcPath = node["srcPath"].Value <string>();
     }
     if (node["srcEncKey"] != null)
     {
         this._SrcEncKey = node["srcEncKey"].Value <string>();
     }
     if (node["storageClass"] != null)
     {
         this._StorageClass = node["storageClass"].Value <string>();
     }
 }
        public FileSyncBaseFilter(XmlElement node) : base(node)
        {
            foreach (XmlElement propertyNode in node.ChildNodes)
            {
                switch (propertyNode.Name)
                {
                case "partnerIdEqual":
                    this._PartnerIdEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "fileObjectTypeEqual":
                    this._FileObjectTypeEqual = (FileSyncObjectType)StringEnum.Parse(typeof(FileSyncObjectType), propertyNode.InnerText);
                    continue;

                case "fileObjectTypeIn":
                    this._FileObjectTypeIn = propertyNode.InnerText;
                    continue;

                case "objectIdEqual":
                    this._ObjectIdEqual = propertyNode.InnerText;
                    continue;

                case "objectIdIn":
                    this._ObjectIdIn = propertyNode.InnerText;
                    continue;

                case "versionEqual":
                    this._VersionEqual = propertyNode.InnerText;
                    continue;

                case "versionIn":
                    this._VersionIn = propertyNode.InnerText;
                    continue;

                case "objectSubTypeEqual":
                    this._ObjectSubTypeEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "objectSubTypeIn":
                    this._ObjectSubTypeIn = propertyNode.InnerText;
                    continue;

                case "dcEqual":
                    this._DcEqual = propertyNode.InnerText;
                    continue;

                case "dcIn":
                    this._DcIn = propertyNode.InnerText;
                    continue;

                case "originalEqual":
                    this._OriginalEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "createdAtGreaterThanOrEqual":
                    this._CreatedAtGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "createdAtLessThanOrEqual":
                    this._CreatedAtLessThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "updatedAtGreaterThanOrEqual":
                    this._UpdatedAtGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "updatedAtLessThanOrEqual":
                    this._UpdatedAtLessThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "readyAtGreaterThanOrEqual":
                    this._ReadyAtGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "readyAtLessThanOrEqual":
                    this._ReadyAtLessThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "syncTimeGreaterThanOrEqual":
                    this._SyncTimeGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "syncTimeLessThanOrEqual":
                    this._SyncTimeLessThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "statusEqual":
                    this._StatusEqual = (FileSyncStatus)ParseEnum(typeof(FileSyncStatus), propertyNode.InnerText);
                    continue;

                case "statusIn":
                    this._StatusIn = propertyNode.InnerText;
                    continue;

                case "fileTypeEqual":
                    this._FileTypeEqual = (FileSyncType)ParseEnum(typeof(FileSyncType), propertyNode.InnerText);
                    continue;

                case "fileTypeIn":
                    this._FileTypeIn = propertyNode.InnerText;
                    continue;

                case "linkedIdEqual":
                    this._LinkedIdEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "linkCountGreaterThanOrEqual":
                    this._LinkCountGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "linkCountLessThanOrEqual":
                    this._LinkCountLessThanOrEqual = ParseInt(propertyNode.InnerText);
                    continue;

                case "fileSizeGreaterThanOrEqual":
                    this._FileSizeGreaterThanOrEqual = ParseFloat(propertyNode.InnerText);
                    continue;

                case "fileSizeLessThanOrEqual":
                    this._FileSizeLessThanOrEqual = ParseFloat(propertyNode.InnerText);
                    continue;
                }
            }
        }
Example #4
0
        public FileSync(XmlElement node) : base(node)
        {
            foreach (XmlElement propertyNode in node.ChildNodes)
            {
                switch (propertyNode.Name)
                {
                case "id":
                    this._Id = ParseLong(propertyNode.InnerText);
                    continue;

                case "partnerId":
                    this._PartnerId = ParseInt(propertyNode.InnerText);
                    continue;

                case "fileObjectType":
                    this._FileObjectType = (FileSyncObjectType)StringEnum.Parse(typeof(FileSyncObjectType), propertyNode.InnerText);
                    continue;

                case "objectId":
                    this._ObjectId = propertyNode.InnerText;
                    continue;

                case "version":
                    this._Version = propertyNode.InnerText;
                    continue;

                case "objectSubType":
                    this._ObjectSubType = ParseInt(propertyNode.InnerText);
                    continue;

                case "dc":
                    this._Dc = propertyNode.InnerText;
                    continue;

                case "original":
                    this._Original = ParseInt(propertyNode.InnerText);
                    continue;

                case "createdAt":
                    this._CreatedAt = ParseInt(propertyNode.InnerText);
                    continue;

                case "updatedAt":
                    this._UpdatedAt = ParseInt(propertyNode.InnerText);
                    continue;

                case "readyAt":
                    this._ReadyAt = ParseInt(propertyNode.InnerText);
                    continue;

                case "syncTime":
                    this._SyncTime = ParseInt(propertyNode.InnerText);
                    continue;

                case "status":
                    this._Status = (FileSyncStatus)ParseEnum(typeof(FileSyncStatus), propertyNode.InnerText);
                    continue;

                case "fileType":
                    this._FileType = (FileSyncType)ParseEnum(typeof(FileSyncType), propertyNode.InnerText);
                    continue;

                case "linkedId":
                    this._LinkedId = ParseInt(propertyNode.InnerText);
                    continue;

                case "linkCount":
                    this._LinkCount = ParseInt(propertyNode.InnerText);
                    continue;

                case "fileRoot":
                    this._FileRoot = propertyNode.InnerText;
                    continue;

                case "filePath":
                    this._FilePath = propertyNode.InnerText;
                    continue;

                case "fileSize":
                    this._FileSize = ParseFloat(propertyNode.InnerText);
                    continue;

                case "fileUrl":
                    this._FileUrl = propertyNode.InnerText;
                    continue;

                case "fileContent":
                    this._FileContent = propertyNode.InnerText;
                    continue;

                case "fileDiscSize":
                    this._FileDiscSize = ParseFloat(propertyNode.InnerText);
                    continue;

                case "isCurrentDc":
                    this._IsCurrentDc = ParseBool(propertyNode.InnerText);
                    continue;

                case "isDir":
                    this._IsDir = ParseBool(propertyNode.InnerText);
                    continue;

                case "originalId":
                    this._OriginalId = ParseInt(propertyNode.InnerText);
                    continue;
                }
            }
        }