private List <SyncResultObject> GetFoldersAndSync(Content cntToSync, string filePath)
        {
            var result = new List <SyncResultObject>();

            // update files
            result.AddRange(GetFilesAndSync(cntToSync, filePath));

            // now the folders
            DirectoryInfo[] folderInfos = null;
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(filePath);
                folderInfos = dirInfo.GetDirectories();
            }
            catch
            {
                // no problem, there are no folder's here. so what?
            }

            // nothing use this
            //IEnumerable<Content> children = cntToSync.Children.Where(c => c.TypeIs("Folder"));

            if (folderInfos != null && folderInfos.Length > 0)
            {
                foreach (var folder in folderInfos)
                {
                    string folderName = string.Empty;
                    try
                    {
                        folderName = ContentNamingHelper.GetNameFromDisplayName(folder.Name);
                        Content folderContent = cntToSync.Children.Where(c => c.Name == folderName).FirstOrDefault();
                        if (folderContent == null)
                        {
                            var fileSyncAspect = Aspect.LoadAspectByPathOrName(ASPECTNAME);
                            folderContent             = Content.CreateNew("Folder", cntToSync.ContentHandler, folderName);
                            folderContent.DisplayName = folder.Name;
                            folderContent.AddAspects(fileSyncAspect);
                            folderContent.Save();
                        }

                        result.AddRange(GetFoldersAndSync(folderContent, folder.FullName));
                    }
                    catch
                    {
                        result.Add(new SyncResultObject(string.Concat(cntToSync.Path, "/", folderName), SyncResult.SyncFailed));
                    }
                }
            }

            //// save sync date on parent
            SaveAsTechnicalUser(cntToSync, null, true);

            return(result);
        }
Esempio n. 2
0
        public override object Execute(Content content, params object[] parameters)
        {
            var aspectPaths = (string[])parameters[0];
            var gc          = content.ContentHandler as GenericContent;

            if (gc == null)
            {
                throw new InvalidOperationException("Cannot add an aspect to a content that is not a GenericContent.");
            }
            var aspects = new Aspect[aspectPaths.Length];

            for (int i = 0; i < aspectPaths.Length; i++)
            {
                var pathOrName = aspectPaths[i];
                aspects[i] = Aspect.LoadAspectByPathOrName(pathOrName);
                if (aspects[i] == null)
                {
                    throw new InvalidOperationException("Unknown aspect: " + aspectPaths[i]);
                }
            }
            content.AddAspects(aspects);
            content.Save();
            return(null);
        }
        private List <SyncResultObject> GetFilesAndSync(Content cntToSync, string filePath)
        {
            var result = new List <SyncResultObject>();

            DirectoryInfo         dirInfo  = new DirectoryInfo(filePath);
            IEnumerable <Content> children = cntToSync.Children.Where(c => c.TypeIs("File"));
            //Content lastContent = children.OrderByDescending(c => c.CreationDate).FirstOrDefault();
            //DateTime lastContentDate = (lastContent != null) ? lastContent.CreationDate : DateTime.MinValue;
            //technical debt: I think creationdate won't be good here, we should probably use last syncdate

            var fileInfos = dirInfo.GetFiles();

            //if (fileInfos.Length == 0)
            //    result.Add(new SyncResultObject(filePath, SyncResult.NoSyncToDo));
            //else
            if (fileInfos.Length > 0)
            {
                foreach (var file in fileInfos)
                {
                    var    fileSynced = false;
                    string fileName   = file.Name;
                    try
                    {
                        using (Stream fileStream = file.Open(FileMode.Open, FileAccess.Read)) //Open the file ReadOnly mode
                        {
                            fileName = ContentNamingHelper.GetNameFromDisplayName(file.Name);

                            using (new SystemAccount())
                            {//Technical Debt: as for now we do not check if file needs to be updated or not
                                Content fileContent = cntToSync.Children.Where(c => c.Name == fileName).FirstOrDefault();
                                if (fileContent == null)
                                {
                                    // create new
                                    SenseNet.ContentRepository.File newFile = new SenseNet.ContentRepository.File(cntToSync.ContentHandler);
                                    newFile.Name        = ContentNamingHelper.GetNameFromDisplayName(file.Name);
                                    newFile.DisplayName = file.Name;
                                    newFile.Save();
                                    fileContent = Content.Load(newFile.Id);
                                    var fileSyncAspect = Aspect.LoadAspectByPathOrName(ASPECTNAME);
                                    fileContent.Save(); // ez miert? elo is kell menteni?
                                    fileContent.AddAspects(fileSyncAspect);
                                }

                                SaveAsTechnicalUser(fileContent, fileStream);
                                result.Add(new SyncResultObject(fileContent.Path, SyncResult.SyncSuccess));
                            }
                            fileSynced = true;
                        }
                    }
                    catch (Exception ex)
                    {
                        SnLog.WriteException(ex);
                        result.Add(new SyncResultObject(string.Concat(cntToSync.Path, "/", fileName), SyncResult.SyncFailed));
                    }

                    // result add would be better at here

                    // delete file
                    try
                    {
                        if (fileSynced)
                        {
                            //Logger.WriteInformation(40002, "FILESYNC delete 545 " + file.Name);
                            file.Delete();
                        }
                        // should we log deletion?
                    }
                    catch (Exception ex)
                    {
                        SnLog.WriteException(ex);
                    }
                }
            }

            //// save refresh date on parent
            //SaveAsTechnicalUser(cntToSync, null, true);

            return(result);
        }