public static guidanceItem xmlDB_NewGuidanceItem(this TM_Xml_Database tmDatabase, Guid guidanceItemId, 
															  string title, string images,
//															  DateTime lastUpdate, 
															  string topic, string technology, string category, 
															  string ruleType, string priority, string status, 
															  string author,string phase,  string htmlContent, 
															  Guid libraryId
															  )
        {
            var guidanceItem  = new guidanceItem()
                                    {
                                        id = (guidanceItemId == Guid.Empty)
                                                    ? Guid.NewGuid().str()
                                                    : guidanceItemId.str(),
                                        Author = author,
                                        Category = category,
                                        content = htmlContent,
                    //					Date = lastUpdate.str(),
                                        Priority = priority,
                                        Rule_Type = ruleType,
                                        //.Source ;
                                        Status = status,
                                        Technology = technology,
                                        title = title,
                                        Topic = topic,
                                        phase = phase,
                                        libraryId = libraryId.str()
                            //			.Type1;
                            //			.type;
                                    };
            guidanceItem.xmlDB_Save_GuidanceItem(libraryId, tmDatabase);
            return guidanceItem;
        }
		public static guidanceExplorer xmlDB_NewGuidanceExplorer(this TM_Xml_Database tmDatabase, Guid libraryId, string caption)
		{
			"[TM_Xml_Database][xmlDB_NewGuidanceExplorer] Creating new Library with id {0} and caption {1}".info(libraryId, caption);
			if (caption.isValidGuidanceExplorerName().isFalse())
			{
				"[TM_Xml_Database][xmlDB_NewGuidanceExplorer] provided caption didn't pass validation regex".error();
				throw new Exception("Provided Library name didn't pass validation regex"); 				
			}
			
			if (tmDatabase.tmLibrary(caption).notNull())
			{
				"[TM_Xml_Database] in xmlDB_NewGuidanceExplorer, a library with that name already existed: {0}".error(caption);
				return null;
			}
			if (libraryId == Guid.Empty)
				libraryId = Guid.NewGuid();
			var newGuidanceExplorer = new urn.microsoft.guidanceexplorer.guidanceExplorer();  
			newGuidanceExplorer.library = new urn.microsoft.guidanceexplorer.Library(); 			
			newGuidanceExplorer.library.items = new urn.microsoft.guidanceexplorer.Items();
			newGuidanceExplorer.library.libraryStructure = new urn.microsoft.guidanceexplorer.LibraryStructure();			
			//newGuidanceExplorer.library.libraryStructure.folder = new List<urn.microsoft.guidanceexplorer.Folder>();  
			//newGuidanceExplorer.library.libraryStructure.view = new List<urn.microsoft.guidanceexplorer.View>();  
			newGuidanceExplorer.library.name = libraryId.str();
			newGuidanceExplorer.library.caption = caption; 
			"xmlLibraryPath: {0}".info(TM_Xml_Database.Path_XmlLibraries);
			//var newLibraryPath = TM_Xml_Database.Path_XmlLibraries.pathCombine("{0}.xml".format(caption));
			
			newGuidanceExplorer.xmlDB_Save_GuidanceExplorer(tmDatabase);
			//"saving new library to: {0}".info(newLibraryPath);			
			//newGuidanceExplorer.Save(newLibraryPath);			
			//tmDatabase.setGuidanceExplorerObjects();	// reload these values
			
			return newGuidanceExplorer;
		}
 public static TeamMentor_Article fixGuidanceItemFileDueToGuidConflict(this TM_Xml_Database tmDatabase, Guid original_Guid, string fullPath)
 {
     var newGuid = Guid.NewGuid();
     var newPath = fullPath.replace(original_Guid.str(), newGuid.str());
     Files.moveFile(fullPath, newPath);
     "[xmlDB_GuidanceItem] resolved GuidanceItem ID conflict for  Id '{0}' was already mapped. \nExisting path: \t{1} \nNew path:  \t{2}".error(original_Guid, fullPath , newPath);
     var guidanceItemV3 = tmDatabase.xmlDB_GuidanceItem(newGuid, newPath);
     return guidanceItemV3;
 }
 public static GuidanceItem newGuidanceItemObject(Guid id, string title, Guid guidanceType, Guid library, Guid creator, string creatorCaption, string content, string images, DateTime lastUpdate)
 {
     var guidanceItem = new GuidanceItem  { id =id.str(),
                                             title = title,
                                             guidanceType = guidanceType.str(),
                                             library = library.str(),
                                             creator = creator.str(),
                                             creatorCaption = creatorCaption,
                                             content = content,
                                             images = images,
                                             lastUpdate = lastUpdate
                                           };
     return guidanceItem;
 }
 public bool RenameLibrary(Guid libraryId, string newName)
 {
     this.resetCache();
     if (javascriptProxy.GetLibraryById(libraryId.str()).isNull())
         return false;
     var libraryToRename = new Library  { id = libraryId.str(), caption = newName };
     return javascriptProxy.UpdateLibrary(libraryToRename);
 }
 public bool SetArticleContent(Guid articleId, string dataType,  string content)
 {
     resetCache();
                                                                                     var article = javascriptProxy.GetGuidanceItemById(articleId.str());
                                                                                     if (article.notNull())
                                                                                     {
                                                                                         article.Content.Data.Value = content;
                                                                                         article.Content.DataType = dataType;
                                                                                         return javascriptProxy.UpdateGuidanceItem(article);
                                                                                     }
                                                                                     return false;
 }
 public bool DeleteLibrary(Guid libraryId)
 {
     this.resetCache();
     if (javascriptProxy.GetLibraryById(libraryId.str()).isNull())
         return false;
     var libraryToDelete = new Library  { id = libraryId.str(), delete = true };
     javascriptProxy.UpdateLibrary(libraryToDelete);
     var libraryDeleted = javascriptProxy.GetLibraryById(libraryId.str());
     return libraryDeleted.isNull();// || libraryDeleted.delete;
 }
 public Library GetLibraryById(Guid libraryId)
 {
     return javascriptProxy.GetLibraryById	 (libraryId.str());
 }
		//[PrincipalPermission(SecurityAction.Demand, Role = "EditArticles")]
		public static GuidanceItem_V3 xmlDB_GuidanceItem(this TM_Xml_Database tmDatabase, Guid guidanceItemId, string fullPath)
		{
			try
			{
				if (TM_Xml_Database.Cached_GuidanceItems.hasKey(guidanceItemId))
				{
					//"found match for id: {0} in {1}".info(guidanceItemId, fullPath);
					if (TM_Xml_Database.GuidanceItems_FileMappings[guidanceItemId] != fullPath)
					{						
						//"[xmlDB_GuidanceItem] GuidanceItem ID conflict, the Id '{0}' was already mapped. \nExisting path: \t{1} \nNew path:  \t{2}".error(
						//	guidanceItemId, TM_Xml_Database.GuidanceItems_FileMappings[guidanceItemId] , fullPath);
						return tmDatabase.fixGuidanceItemFileDueToGuidConflict(guidanceItemId, fullPath);
					}
					return TM_Xml_Database.Cached_GuidanceItems[guidanceItemId]; 
				}
				
				if(fullPath.notNull())
				{
					//"trying to load id {0} from virtualPath: {1}".info(guidanceItemId, virtualPath);				
					var pathXmlLibraries = TM_Xml_Database.Path_XmlLibraries;
					/*var fullPath = virtualPath.fileExists() 
										? virtualPath
										: pathXmlLibraries.pathCombine(virtualPath).fullPath();*/
					if (fullPath.fileExists())									
					{
						//"loading {0}".info(fullPath);
						var _guidanceItem = guidanceItem.Load(fullPath);				
						if (_guidanceItem.notNull())
						{
							if(_guidanceItem.id.guid() != guidanceItemId)
							{
								"FOUND GUID CHANGE".error();
								_guidanceItem.id_original = _guidanceItem.id;
								_guidanceItem.id 		  = guidanceItemId.str();
								_guidanceItem.Save(fullPath);								
							}
						//guidanceItemV3.guidanceItemId		 = original_Guid;		// this gives us the ability to track its source 
						//guidanceItemV3.source_guidanceItemId = newGuid;				// also provides support for moving GuidanceItems across libraries
							var _guidanceItemV3 = _guidanceItem.tmGuidanceItemV3();
							
							TM_Xml_Database.Cached_GuidanceItems.Add(guidanceItemId, _guidanceItemV3);
							TM_Xml_Database.GuidanceItems_FileMappings.add(guidanceItemId, fullPath);
							
							
							return _guidanceItemV3;
						}					
					}
					else
						"[xmlDB_GuidanceItem] could not find file: {0}".error(fullPath);
				}
				else
					"no virtualPath provided for id: {0}".error(guidanceItemId);
			}
			catch(Exception ex)
			{
				"[TM_Xml_Database] in xmlDB_GuidanceItem: {0}".error(ex.Message);
			}
			return null;
		}								
        public bool UpdateGuidanceItemHtml(Guid guidanceItemId, string htmlContent)
        {
            var guidanceItem = javascriptProxy.GetGuidanceItemById(guidanceItemId.str());

            new PagesHistory().logPageChange(guidanceItemId, currentUser.UserName, sessionID, guidanceItem.htmlContent.sanitizeHtmlContent());

            guidanceItem.htmlContent = htmlContent.sanitizeHtmlContent();

            return javascriptProxy.UpdateGuidanceItem(guidanceItem);
        }
 public static urn.microsoft.guidanceexplorer.Folder xmlDB_Folder(this TM_Xml_Database tmDatabase, Guid libraryId, Guid folderId)
 {
     foreach(var folder in tmDatabase.xmlDB_Folders_All(libraryId))
         if(folder.folderId == folderId.str())
             return folder;
     return null;
 }
 public bool IsGuidMappedInThisServer(Guid guid)
 {
     if (GetGuidanceItemById(guid.str()).notNull())
                                                 return true;
                                             if (TM_Xml_Database.Current.get_GuidRedirect(guid).valid())
                                                 return true;
                                             return false;
 }
		[WebMethod(EnableSession = true)] 	public Library GetLibraryById  (Guid libraryId) 						    { return javascriptProxy.GetLibraryById	 (libraryId.str()); }		
示例#14
0
文件: Crypto.cs 项目: roman87/Dev
 public static string hash_PBKDF2(this string password, Guid salt)
 {
     return password.hash_PBKDF2(salt.str());
 }
 public static urn.microsoft.guidanceexplorer.Folder xmlDB_Folder(this TM_Xml_Database tmDatabase, Guid libraryId, Guid folderId)
 {
     return tmDatabase.xmlDB_Folders_All(libraryId)
                      .FirstOrDefault(folder => folder.folderId == folderId.str());
 }
 public static urn.microsoft.guidanceexplorer.Folder xmlDB_Folder(this TM_Xml_Database tmDatabase, Guid libraryId, Guid parentFolder,string folderName)
 {
     return tmDatabase.xmlDB_Folders_All(libraryId)
                      .Where(folder => folder.folderId == parentFolder.str())
                      .SelectMany(folder => folder.folder1)
                      .FirstOrDefault(subFolder => subFolder.caption == folderName);
 }
        public static guidanceExplorer xmlDB_NewGuidanceExplorer(this TM_Xml_Database tmDatabase, Guid libraryId, string caption)
        {
            if (caption.isNull() || caption.isValidGuidanceExplorerName().isFalse())
            {
                "[TM_Xml_Database] [xmlDB_NewGuidanceExplorer] provided caption didn't pass validation regex".error();
                throw new Exception("Provided Library name didn't pass validation regex");
            }

            if (tmDatabase.tmLibrary(caption).notNull())
            {
                "[TM_Xml_Database] in xmlDB_NewGuidanceExplorer, a library with that name already existed: {0}".error(caption);
                return null;
            }
            if (libraryId == Guid.Empty)
                libraryId = Guid.NewGuid();
            var newGuidanceExplorer = new guidanceExplorer
                {
                    library = new urn.microsoft.guidanceexplorer.Library
                                {
                                    items = new Items(),
                                    libraryStructure = new LibraryStructure(),
                                    name = libraryId.str(),
                                    caption = caption
                                }
                };

            TM_Xml_Database.Current.GuidanceExplorers_XmlFormat.add(libraryId, newGuidanceExplorer);    //add to in memory database
            newGuidanceExplorer.xmlDB_Save_GuidanceExplorer(tmDatabase);
            "[TM_Xml_Database] [xmlDB_NewGuidanceExplorer] Created new Library with id {0} and caption {1}".info(libraryId, caption);
            return newGuidanceExplorer;
        }
        public static Library_V3 getFolderStructure_Library(this IJavascriptProxy javascriptProxy, Guid libraryId, TM_GUI_Objects guiObjects)
        {
            //pre-create this mapping since the view retrieval was a massive performance bottle neck
            var allViews = new Dictionary<Guid, View_V3>();
            foreach(var view in javascriptProxy.GetViews())
                allViews.Add(view.viewId, view);

            Action<Folder_V3> mapFolderViews =  null;

            Func<List<Guid>, List<View_V3>> mapViews =
                (viewGuids) =>
                            {
                                var views = new List<View_V3>();

                                foreach(var viewGuid in viewGuids)
                                {
                                    var view = 	allViews[viewGuid];

                                    /*// compress view.guidanceItems using guiObjects
                                    view.guidanceItems_Indexes = (from guid in view.guidanceItems
                                                                  select guiObjects.get_Index(guid.str()).str()).toList()
                                                                  .join(",").remove(" ");
                                    view.guidanceItems.Clear();*/
                                    views.add(view);
                                }
                                return views;
                            };

            mapFolderViews =
                (folder) => {
                                 var mappedViews = mapViews(folder.views.guids());
                                 folder.views.Clear();
                                 folder.views.add(mappedViews);
                                 foreach(var subFolder in folder.subFolders)
                                    mapFolderViews(subFolder);
                            };

            Action<List<Folder_V3>, List<Folder_V3>> mapFolders = (folders, parentFolder) =>
                {
                    foreach(var folder in folders)
                    {
                        var folderId = folder.folderId;
                        parentFolder.add(folder);
                        mapFolderViews(folder);
                    }
                };

            Func<Guid,string, Library_V3> mapLibrary =
                (_libraryId, libraryName)=> {
                                        var libraryV3 = new Library_V3()
                                                    {
                                                        libraryId = _libraryId,
                                                        name = libraryName
                                                    };
                                        mapFolders(javascriptProxy.GetFolders(_libraryId), libraryV3.subFolders);
                                        libraryV3.views.add(mapViews(javascriptProxy.GetViewsInLibraryRoot(libraryId.str()).guids()));
                                        libraryV3.guidanceItems = javascriptProxy.getGuidanceItemsIds_NotInViews(_libraryId);
                                        return libraryV3;
                                    };

            Func<Guid,Library_V3> getLibrary_TreeStructure =
                (_libraryId)=>{
                                var tmLibrary = javascriptProxy.GetLibraryById(_libraryId.str());
                                if (tmLibrary.isNull())
                                {
                                    "[in getLibraryFolderStructure] could not find library with id: {0}".error(_libraryId);
                                    return null;
                                }
                                return mapLibrary(_libraryId, tmLibrary.caption);
                            };
            return getLibrary_TreeStructure(libraryId);
        }
 public static urn.microsoft.guidanceexplorer.View xmlDB_View(this TM_Xml_Database tmDatabase, Guid viewId)
 {
     return (from view in tmDatabase.xmlDB_Views()
             where view.id == viewId.str()
             select view).first();
 }
		[WebMethod(EnableSession = true)]   [EditArticles(SecurityAction.Demand)]   public bool SetArticleContent (Guid articleId, string dataType,  string content)					        
                                                                                        { 
                                                                                            resetCache();
                                                                                            var article = javascriptProxy.GetGuidanceItemById(articleId.str());
                                                                                            if (article.notNull())
                                                                                            {
                                                                                                article.Content.Data.Value = content;
                                                                                                article.Content.DataType = dataType;
                                                                                                return javascriptProxy.UpdateGuidanceItem(article);                                                                                                
                                                                                            }
                                                                                            return false;
                                                                                        }
示例#21
0
 public bool RenameGuidanceItemTitle(Guid guidanceItemId, string title)
 {
     this.resetCache();
     try
     {
         var guidanceItem = GetGuidanceItemById(guidanceItemId.str());
         guidanceItem.title = title;
         return UpdateGuidanceItem(guidanceItem);
     }
     catch//(Exception ex)
     {
         return false;
     }
 }
        public static string get_GuidRedirect(this TM_Xml_Database tmXmlDatabase, Guid id)
        {
            var virtualArticle = tmXmlDatabase.virtualArticle(id);
            if (virtualArticle.notNull())
            {
                if (virtualArticle.Action == "Redirect")
                {
                    var redirect = virtualArticle.Redirect_Uri.str();
                    "Found Guid Rediction: {0} -> {1}".info(id, redirect);
                    return redirect;
                }

            }
            var virtualArticles_Config = tmXmlDatabase.tmConfig().VirtualArticles;
            if (virtualArticles_Config.AutoRedirectIfGuidNotFound)
            {
                var redirect = virtualArticles_Config.AutoRedirectTarget.pathCombine(id.str());
                "[AutoRedirectIfGuidNotFound is set] set redirection to {0}".info(redirect);
                return redirect;
            }
            return null;
        }
		//Extra (not in Javascript proxy (move to separate file if more than a couple are needed)
		[WebMethod(EnableSession = true)] [EditArticles(SecurityAction.Demand)]		public bool DeleteLibrary(Guid libraryId)
		{
			this.resetCache();
			if (javascriptProxy.GetLibraryById(libraryId.str()).isNull())
				return false;
			var libraryToDelete = new Library  { id = libraryId.str(), delete = true };
			javascriptProxy.UpdateLibrary(libraryToDelete);
			var libraryDeleted = javascriptProxy.GetLibraryById(libraryId.str());
			return libraryDeleted.isNull();// || libraryDeleted.delete;
		}		
 public static urn.microsoft.guidanceexplorer.Folder xmlDB_Folder(this TM_Xml_Database tmDatabase, Guid libraryId, Guid parentFolder,string folderName)
 {
     foreach(var folder in tmDatabase.xmlDB_Folders_All(libraryId))
         if(folder.folderId == parentFolder.str())
             foreach(var subFolder in folder.folder1)
                 if (subFolder.caption == folderName)
                     return subFolder;
     return null;
 }
		[WebMethod(EnableSession = true)] [EditArticles(SecurityAction.Demand)]	    public bool RenameLibrary(Guid libraryId, string newName)
		{
			this.resetCache();
			if (javascriptProxy.GetLibraryById(libraryId.str()).isNull())
				return false;
			var libraryToRename = new Library  { id = libraryId.str(), caption = newName };
			return javascriptProxy.UpdateLibrary(libraryToRename);			
		}
 public static urn.microsoft.guidanceexplorer.View xmlDB_View(this urn.microsoft.guidanceexplorer.Folder folder, Guid viewId)
 {
     return (from view in folder.view
             where view.id == viewId.str()
             select view).first();
 }
示例#27
0
 public bool DeleteLibrary(Guid libraryId)
 {
     editArticles.demand();
                                                         resetCache();
                                                         if (GetLibraryById(libraryId).isNull())
                                                             return false;
                                                         var libraryToDelete = new Library  { id = libraryId.str(), delete = true };
                                                         UpdateLibrary(libraryToDelete);
                                                         var libraryDeleted = GetLibraryById(libraryId);
                                                         return libraryDeleted.isNull();// || libraryDeleted.delete;
 }
		public static bool xmlDB_Save_GuidanceItem(this guidanceItem guidanceItem, Guid libraryId, TM_Xml_Database tmDatabase)
		{
			var xmlLibraries = TM_Xml_Database.Path_XmlLibraries;
			var guidanceXmlPath = tmDatabase.getXmlFilePathForGuidanceId(guidanceItem.id.guid(), libraryId);
			
			"Saving GuidanceItem {0} to {1}".info(guidanceItem.id, guidanceXmlPath);				
			
			guidanceItem.libraryId = libraryId.str();			
			guidanceItem.Save(guidanceXmlPath);			
			//add it to in Memory cache

			tmDatabase.setGuidanceExplorerObjects();
			guidanceItem.update_Cache_GuidanceItems(tmDatabase);			
			
			return guidanceXmlPath.fileExists();			
		}		
示例#29
0
 public bool RenameLibrary(Guid libraryId, string newName)
 {
     editArticles.demand();
                                                         resetCache();
                                                         if (GetLibraryById(libraryId).isNull())
                                                             return false;
                                                         var libraryToRename = new Library  { id = libraryId.str(), caption = newName };
                                                         return UpdateLibrary(libraryToRename);
 }