public static IDirectoryDefinition DirectoryDefinitionMapper(Model.Directory directoryDefinition)
        {
            IDirectoryDefinition directory = null;

            try
            {
                directory = ConfigurationComponentFactory().ConfigurationFactory <IDirectoryDefinition>(typeof(IDirectoryDefinition));
            }
            catch (Exception e)
            {
                throw new DataAccessComponentException(null, -1, "Configuration proxy factory failure - unable to create an instance of " + typeof(IDirectoryDefinition) + "?", e);
            }


            try
            {
                directory.Enabled = directoryDefinition.Enabled;
                directory.Path    = directoryDefinition.Path;
            }
            catch (Exception e)
            {
                throw new DataAccessComponentException(null, -1, "Mapping process failure?", e);
            }
            return(directory);
        }
Example #2
0
 public void Remove(Model.Directory item)
 {
     using (var conn = Database.Open())
     {
         conn.Execute(DirectorySql.Remove(item.Id));
     }
 }
Example #3
0
        //======================================================================
        public Directory(Model.Directory model)
        {
            this.Model = model;

            this.Model.FreshnessUpdated += this.OnTextFontUpdated;
            this.Model.ChildrenUpdated  += this.OnChildrenUpdated;
        }
        /// <summary>
        /// 更新目录
        /// </summary>
        /// <param name="directoryId">目录ID</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public Return Update(int directoryId, string description, string pingApiPath, string versionApiPath, int directoryType)
        {
            Model.Directory directory = Model.RepositoryRegistry.Directory.FindBy(directoryId);
            if (directory == null)
            {
                return(new Return()
                {
                    Code = "d00003", Message = "目录不存在"
                });
            }

            directory.Description    = description;
            directory.PingAPIPath    = pingApiPath;
            directory.VersionAPIPath = versionApiPath;
            directory.DirectoryType  = (DirectoryType)directoryType;

            if (directory.Validate())
            {
                Model.RepositoryRegistry.Directory.Update(directory);
                return(new Return());
            }
            return(new Return()
            {
                Message = directory.GetBrokenRules()[0].Description, Code = directory.GetBrokenRules()[0].Name
            });
        }
Example #5
0
 public void Update(Model.Directory item)
 {
     using (var conn = Database.Open())
     {
         var tuple = DirectorySql.Update(item);
         conn.Execute(tuple.Item1, (object)tuple.Item2);
     }
 }
Example #6
0
 public bool DirectoryIsExists(Model.Directory d)
 {
     using (var conn = Database.Open())
     {
         var tuple = DirectorySql.DirectoryIsExists(d.Name, d.Id);
         return(conn.ExecuteScalar <int>(tuple.Item1, (object)tuple.Item2) > 0);
     }
 }
Example #7
0
        internal static List <Model.File> GetDirectoryFiles(this Model.Directory directory,
                                                            Dictionary <String, Dictionary <String, String> > metadataProperties = null)
        {
            var result = new List <Model.File>();

            // If the connector has a container specified we need to take that in account to find the files we need
            string folderToGrabFilesFrom = directory.Src;

            if (!String.IsNullOrEmpty(directory.ParentTemplate.Connector.GetContainer()))
            {
                folderToGrabFilesFrom = directory.ParentTemplate.Connector.GetContainer() + @"\" + directory.Src;
            }

            var files = directory.ParentTemplate.Connector.GetFiles(folderToGrabFilesFrom);

            if (!String.IsNullOrEmpty(directory.IncludedExtensions) && directory.IncludedExtensions != "*.*")
            {
                var includedExtensions = directory.IncludedExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                files = files.Where(f => includedExtensions.Contains($"*{Path.GetExtension(f).ToLower()}")).ToList();
            }

            if (!String.IsNullOrEmpty(directory.ExcludedExtensions))
            {
                var excludedExtensions = directory.ExcludedExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                files = files.Where(f => !excludedExtensions.Contains($"*{Path.GetExtension(f).ToLower()}")).ToList();
            }

            result.AddRange(from file in files
                            select new Model.File(
                                directory.Src + @"\" + file,
                                directory.Folder,
                                directory.Overwrite,
                                null, // No WebPartPages are supported with this technique
                                metadataProperties != null && metadataProperties.ContainsKey(directory.Src + @"\" + file) ?
                                metadataProperties[directory.Src + @"\" + file] : null,
                                directory.Security,
                                directory.Level
                                ));

            if (directory.Recursive)
            {
                var subFolders   = directory.ParentTemplate.Connector.GetFolders(folderToGrabFilesFrom);
                var parentFolder = directory;
                foreach (var folder in subFolders)
                {
                    directory.Src    = parentFolder.Src + @"\" + folder;
                    directory.Folder = parentFolder.Folder + @"\" + folder;

                    result.AddRange(directory.GetDirectoryFiles(metadataProperties));

                    //Remove the subfolder path(added above) as the second subfolder should come under its parent folder and not under its sibling
                    parentFolder.Src    = parentFolder.Src.Substring(0, parentFolder.Src.LastIndexOf(@"\"));
                    parentFolder.Folder = parentFolder.Folder.Substring(0, parentFolder.Folder.LastIndexOf(@"\"));
                }
            }

            return(result);
        }
Example #8
0
        public void Add(Model.Directory item)
        {
            using (var conn = Database.Open())
            {
                var tuple = DirectorySql.Add(item);

                int id = conn.ExecuteScalar <int>(tuple.Item1, (object)tuple.Item2);
                propertyHelper.SetValue <int>(m => m.Id, item, id);
            }
        }
Example #9
0
 void DirectoryAssert(Model.Directory expected, Model.Directory actual)
 {
     Assert.AreEqual(expected.Id, actual.Id);
     Assert.AreEqual(expected.Name, actual.Name);
     Assert.AreEqual(expected.PingAPIPath, actual.PingAPIPath);
     Assert.AreEqual(expected.VersionAPIPath, actual.VersionAPIPath);
     Assert.AreEqual(expected.DirectoryType, actual.DirectoryType);
     Assert.AreEqual(expected.Description, actual.Description);
     Assert.AreEqual(expected.CreateDate.Hour, actual.CreateDate.Hour);
     Assert.AreEqual(expected.UsedServiceMd5, actual.UsedServiceMd5);
     Assert.AreEqual(expected.SerivceApiMd5, actual.SerivceApiMd5);
 }
Example #10
0
        public static Model.Directory Create(Model.DirectoryType directoryType = Model.DirectoryType.提供者)
        {
            var directory = new Model.Directory("订单服务")
            {
                Description    = "sdfkfjsdlf",
                DirectoryType  = directoryType,
                PingAPIPath    = "/adfaf/adff",
                VersionAPIPath = "/dfadfadf/adfad",
                SerivceApiMd5  = "a",
                UsedServiceMd5 = "b"
            };

            return(directory);
        }
Example #11
0
        internal static List <Model.File> GetDirectoryFiles(this Model.Directory directory,
                                                            Dictionary <String, Dictionary <String, String> > metadataProperties = null)
        {
            Log.Debug(Constants.LOGGING_SOURCE, "Processing Directory {0}", directory.Src);

            var result = new List <Model.File>();

            var files = directory.ParentTemplate.Connector.GetFiles(directory.Src);

            if (!String.IsNullOrEmpty(directory.IncludedExtensions))
            {
                var includedExtensions = directory.IncludedExtensions.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                files = files.Where(f => includedExtensions.Contains($"*{Path.GetExtension(f).ToLower()}")).ToList();
            }

            if (!String.IsNullOrEmpty(directory.ExcludedExtensions))
            {
                var excludedExtensions = directory.ExcludedExtensions.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                files = files.Where(f => !excludedExtensions.Contains($"*{Path.GetExtension(f).ToLower()}")).ToList();
            }

            result.AddRange(from file in files
                            select new Model.File(
                                directory.Src + @"\" + file,
                                directory.Folder,
                                directory.Overwrite,
                                null, // No WebPartPages are supported with this technique
                                metadataProperties != null ? metadataProperties[directory.Src + @"\" + file] : null,
                                directory.Security,
                                directory.Level
                                ));

            if (directory.Recursive)
            {
                var subFolders = directory.ParentTemplate.Connector.GetFolders(directory.Src);

                string _src    = directory.Src;
                string _folder = directory.Folder;

                foreach (var folder in subFolders)
                {
                    directory.Src    = _src + @"\" + folder;
                    directory.Folder = _folder + @"\" + folder;
                    result.AddRange(directory.GetDirectoryFiles(metadataProperties));
                }
            }

            return(result);
        }
Example #12
0
        public static Tuple <string, dynamic> Add(Model.Directory directory)
        {
            const string sql = @"INSERT INTO regisrer_directory
	                            (name, description, ping_api_path, version_api_path, create_date)
	                            VALUES (@Name, @Desc, @PingApiPath, @VersionApiPath, @Date);SELECT last_insert_id()"    ;


            return(new Tuple <string, dynamic>(sql, new
            {
                Name = directory.Name,
                Desc = directory.Description,
                PingApiPath = directory.PingAPIPath,
                VersionApiPath = directory.VersionAPIPath,
                Date = directory.CreateDate
            }));
        }
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="name">目录名称</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public string Create(string name, string description, string pingApiPath, string versionApiPath, int directoryType)
        {
            var directory = new Model.Directory(name)
            {
                Description = description,
                PingAPIPath = pingApiPath,
                VersionAPIPath = versionApiPath,
                DirectoryType = (Model.DirectoryType)directoryType
            };

            if (directory.Validate())
            {
                Model.RepositoryRegistry.Directory.Add(directory);
                return string.Empty;
            }
            return directory.GetBrokenRules()[0].Description;
        }
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="name">目录名称</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public string Create(string name, string description, string pingApiPath, string versionApiPath, int directoryType)
        {
            var directory = new Model.Directory(name)
            {
                Description    = description,
                PingAPIPath    = pingApiPath,
                VersionAPIPath = versionApiPath,
                DirectoryType  = (Model.DirectoryType)directoryType
            };

            if (directory.Validate())
            {
                Model.RepositoryRegistry.Directory.Add(directory);
                return(string.Empty);
            }
            return(directory.GetBrokenRules()[0].Description);
        }
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="name">目录名称</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public Return Create(string name, string description, string pingApiPath, string versionApiPath,int directoryType)
        {
            var directory = new Model.Directory()
            {
                Name = name,
                Description = description,
                PingAPIPath = pingApiPath,
                VersionAPIPath = versionApiPath,
                DirectoryType = (Model.DirectoryType)directoryType
            };

            if (directory.Validate())
            {
                Model.RepositoryRegistry.Directory.Add(directory);
                return new Return();
            }
            return new Return() { Message = directory.GetBrokenRules()[0].Description, Code = directory.GetBrokenRules()[0].Name };
        }
        public static Tuple <string, dynamic> Add(Model.Directory directory)
        {
            const string sql = @"INSERT INTO regisrer_directory
	                            (name, description, ping_api_path, version_api_path, create_date,directory_type,use_services_md5,api_list_md5)
	                            VALUES (@Name, @Desc, @PingApiPath, @VersionApiPath, @Date,@DirectoryType,@UseServiceMd5,@ApiListM5);SELECT last_insert_id()"    ;


            return(new Tuple <string, dynamic>(sql, new
            {
                Name = directory.Name,
                Desc = directory.Description,
                PingApiPath = directory.PingAPIPath,
                VersionApiPath = directory.VersionAPIPath,
                Date = directory.CreateDate,
                DirectoryType = directory.DirectoryType,
                UseServiceMd5 = directory.UsedServiceMd5,
                ApiListM5 = directory.SerivceApiMd5
            }));
        }
        public static Tuple <string, dynamic> Update(Model.Directory directory)
        {
            string sql = @"UPDATE regisrer_directory
                    SET
                        description = @Description,
                        ping_api_path = @PingApiPath,
                        version_api_path = @VersionApiPath,
                        directory_type = @DirectoryType
                    WHERE id = @Id";


            return(new Tuple <string, dynamic>(sql, new
            {
                Description = directory.Description,
                PingApiPath = directory.PingAPIPath,
                VersionApiPath = directory.VersionAPIPath,
                DirectoryType = directory.DirectoryType,
                Id = directory.Id
            }));
        }
        /// <summary>
        /// 更新目录
        /// </summary>
        /// <param name="directoryId">目录ID</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public string Update(int directoryId, string description, string pingApiPath, string versionApiPath, int directoryType)
        {
            Model.Directory directory = RepositoryRegistry.Directory.FindBy(directoryId);
            if (directory == null)
            {
                return("目录不存在");
            }

            directory.Description    = description;
            directory.PingAPIPath    = pingApiPath;
            directory.VersionAPIPath = versionApiPath;
            directory.DirectoryType  = (DirectoryType)directoryType;

            if (directory.Validate())
            {
                RepositoryRegistry.Directory.Update(directory);
                return(string.Empty);
            }
            return(directory.GetBrokenRules()[0].Description);
        }
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="name">目录名称</param>
        /// <param name="description">目录描述</param>
        /// <param name="pingApiPath">pingApi路径</param>
        /// <param name="versionApiPath">版本号Api路径</param>
        /// <param name="directoryType">目录类型</param>
        /// <returns></returns>
        public Return Create(string name, string description, string pingApiPath, string versionApiPath, int directoryType)
        {
            var directory = new Model.Directory()
            {
                Name           = name,
                Description    = description,
                PingAPIPath    = pingApiPath,
                VersionAPIPath = versionApiPath,
                DirectoryType  = (Model.DirectoryType)directoryType
            };

            if (directory.Validate())
            {
                Model.RepositoryRegistry.Directory.Add(directory);
                return(new Return());
            }
            return(new Return()
            {
                Message = directory.GetBrokenRules()[0].Description, Code = directory.GetBrokenRules()[0].Name
            });
        }
Example #20
0
        public static MemoryItem CreateChild(object obj)
        {
            MemoryItem item = null;

            if (obj is FileInfo)
            {
                FileInfo fileInfo = obj as FileInfo;
                item = new Model.File(fileInfo.Name, fileInfo.Extension, fileInfo.FullName, fileInfo.Length, fileInfo.CreationTime);
            }
            if (obj is DirectoryInfo)
            {
                DirectoryInfo directoryInfo = obj as DirectoryInfo;
                item = new Model.Directory(directoryInfo.Name, directoryInfo.Extension, directoryInfo.FullName, directoryInfo.CreationTime);
            }
            if (obj is DriveInfo)
            {
                DriveInfo driveInfo = obj as DriveInfo;
                item = new Model.Drive(driveInfo.Name, driveInfo.Name, driveInfo.TotalSize - driveInfo.TotalFreeSpace);
            }
            return(item);
        }
 public bool DirectoryIsExists(Model.Directory d)
 {
     throw new NotImplementedException();
 }
Example #22
0
        internal static Dictionary <String, Dictionary <String, String> > GetMetadataProperties(this Model.Directory directory)
        {
            Dictionary <String, Dictionary <String, String> > result = null;

            if (directory.MetadataMappingFile != null)
            {
                var metadataPropertiesStream = directory.ParentTemplate.Connector.GetFileStream(directory.MetadataMappingFile);
                if (metadataPropertiesStream != null)
                {
                    using (var sr = new StreamReader(metadataPropertiesStream))
                    {
                        var metadataPropertiesString = sr.ReadToEnd();
                        result = JsonConvert.DeserializeObject <Dictionary <String, Dictionary <String, String> > >(metadataPropertiesString);
                    }
                }
            }

            return(result);
        }
Example #23
0
 //======================================================================
 public TreeRoot(Model.Directory model) : base(model)
 {
 }
 public void Update(Model.Directory item)
 {
     throw new NotImplementedException();
 }
        public static Model.Directory Create(Model.DirectoryType directoryType = Model.DirectoryType.提供者)
        {
            var directory = new Model.Directory("订单服务")
            {
                Description = "sdfkfjsdlf",
                DirectoryType = directoryType,
                PingAPIPath = "/adfaf/adff",
                VersionAPIPath = "/dfadfadf/adfad",
                SerivceApiMd5 = "a",
                UsedServiceMd5 = "b"
            };

            return directory;
        }
        public static Dictionary <string, Dictionary <string, string> > GetMetadataProperties(this Model.Directory directory)
        {
            Dictionary <string, Dictionary <string, string> > result = null;

            if (!string.IsNullOrEmpty(directory.MetadataMappingFile))
            {
                var metadataPropertiesStream = directory.ParentTemplate.Connector.GetFileStream(directory.MetadataMappingFile);
                if (metadataPropertiesStream != null)
                {
                    using (var sr = new StreamReader(metadataPropertiesStream))
                    {
                        var metadataPropertiesString = sr.ReadToEnd();
                        result = JsonSerializer.Deserialize <Dictionary <string, Dictionary <string, string> > >(metadataPropertiesString);
                    }
                }
            }

            return(result);
        }