565 lines
18 KiB
C#
565 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Data.SqlTypes;
|
|
using System.Data;
|
|
|
|
namespace Foo.DataAccessLayer.DataTypes
|
|
{
|
|
// ArtifactTypes
|
|
public enum ArtifactTypes
|
|
{
|
|
File,
|
|
Url
|
|
}
|
|
|
|
// Artifacts
|
|
public enum SortOrderForArtifacts
|
|
{
|
|
None,
|
|
Ascending,
|
|
Descending,
|
|
LocationAscending,
|
|
LocationDescending,
|
|
LastAccessedAscending,
|
|
LastAccessedDescending,
|
|
MostFrequentlyAccessedAscending,
|
|
MostFrequentlyAccessedDescending
|
|
}
|
|
|
|
// Workspaces
|
|
public enum SortOrderForWorkspaces
|
|
{
|
|
None,
|
|
Ascending,
|
|
Descending,
|
|
LastAccessedAscending,
|
|
LastAccessedDescending,
|
|
MostFrequentlyAccessedAscending,
|
|
MostFrequentlyAccessedDescending
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class holds the SortOrder Helper SQL functions for the SortOrder Enums listed above
|
|
/// </summary>
|
|
public class SortOrderSQLHelpers
|
|
{
|
|
/// <summary>
|
|
/// Use this to create the OrderBy Clause for the Workspace SortOrder Function
|
|
/// </summary>
|
|
/// <param name="sql">sql string to add sortOrder to</param>
|
|
/// <param name="sortOrder">the Workspace SortOrder Enum</param>
|
|
/// <returns>modified SQL String</returns>
|
|
public static string SortOrderForArtifactsHelper(string sql, SortOrderForArtifacts sortOrder)
|
|
{
|
|
switch (sortOrder)
|
|
{
|
|
case SortOrderForArtifacts.None:
|
|
break;
|
|
|
|
case SortOrderForArtifacts.Ascending:
|
|
sql = sql + " ORDER BY [Artifacts].[Name] ASC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.Descending:
|
|
sql = sql + " ORDER BY [Artifacts].[Name] DESC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.LastAccessedAscending:
|
|
sql = sql + " ORDER BY [Artifacts].[LastAccessed] ASC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.LastAccessedDescending:
|
|
sql = sql + " ORDER BY [Artifacts].[LastAccessed] DESC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.LocationAscending:
|
|
sql = sql + " ORDER BY [Artifacts].[Location] ASC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.LocationDescending:
|
|
sql = sql + " ORDER BY [Artifacts].[Location] DESC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.MostFrequentlyAccessedAscending:
|
|
sql = sql + " ORDER BY [Artifacts].[AccessCounter] ASC";
|
|
break;
|
|
|
|
case SortOrderForArtifacts.MostFrequentlyAccessedDescending:
|
|
sql = sql + " ORDER BY [Artifacts].[AccessCounter] DESC";
|
|
break;
|
|
}
|
|
return sql;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to create the OrderBy Clause for the Workspace SortOrder Function
|
|
/// </summary>
|
|
/// <param name="sql">sql string to add sortOrder to</param>
|
|
/// <param name="sortOrder">the Workspace SortOrder Enum</param>
|
|
/// <returns>modified SQL String</returns>
|
|
public static string SortOrderForWorkspacesHelper(string sql, SortOrderForWorkspaces sortOrder)
|
|
{
|
|
switch (sortOrder)
|
|
{
|
|
case SortOrderForWorkspaces.None:
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.Ascending:
|
|
sql = sql + " ORDER BY [Workspaces].[Name] ASC";
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.Descending:
|
|
sql = sql + " ORDER BY [Workspaces].[Name] DESC";
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.LastAccessedAscending:
|
|
sql = sql + " ORDER BY [Workspaces].[LastAccessed] ASC";
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.LastAccessedDescending:
|
|
sql = sql + " ORDER BY [Workspaces].[LastAccessed] DESC";
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.MostFrequentlyAccessedAscending:
|
|
sql = sql + " ORDER BY [Workspaces].[AccessCounter] ASC";
|
|
break;
|
|
|
|
case SortOrderForWorkspaces.MostFrequentlyAccessedDescending:
|
|
sql = sql + " ORDER BY [Workspaces].[AccessCounter] DESC";
|
|
break;
|
|
}
|
|
return sql;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validation Classes
|
|
/// </summary>
|
|
public class DataTypeValidation
|
|
{
|
|
/// <summary>
|
|
/// Checks the logistics of the WorkspaceName (not the DB)
|
|
/// </summary>
|
|
/// <returns>true if valid logistically, false otherwise</returns>
|
|
public static bool IsValidWorkspaceName(string WorkspaceName)
|
|
{
|
|
if ((String.IsNullOrEmpty(WorkspaceName)) ||
|
|
(WorkspaceName.Length < 1) ||
|
|
(WorkspaceName.Length > 75))
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to check the return of an ArtifactItemGroup
|
|
/// </summary>
|
|
/// <param name="artifactItems">ArtifactGroup</param>
|
|
/// <returns>true if ArtifactItemGroup is Empty, false otherwise</returns>
|
|
public static bool IsEmptyArtifactItemGroup(ArtifactItem[] artifactItems)
|
|
{
|
|
if ((artifactItems.Length == 1) && !artifactItems[0].IsLocationValid)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to check the return of an WorkspaceItemGroup
|
|
/// </summary>
|
|
/// <param name="artifactItems">WorkspaceItemGroup</param>
|
|
/// <returns>true if WorkspaceItemGroup is Empty, false otherwise</returns>
|
|
public static bool IsEmptyWorkspaceItemGroup(WorkspaceItem[] workspaceItems)
|
|
{
|
|
if ((workspaceItems.Length == 1) && !workspaceItems[0].IsValid)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Uset this for quick and easy DataSet Validation
|
|
/// </summary>
|
|
/// <param name="dataset">a dataset object</param>
|
|
/// <returns>true if dataset is empty, false otherwise</returns>
|
|
public static bool IsEmptyDataSet(DataSet dataset)
|
|
{
|
|
if ((dataset == null) ||
|
|
(dataset.Tables.Count == 0) ||
|
|
((dataset.Tables.Count == 1) && (dataset.Tables[0].Rows.Count <= 0)))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// For internal use only - Check if the TableName entered is Valid
|
|
/// </summary>
|
|
/// <param name="TableName">a table name</param>
|
|
/// <returns>true if valid logistically, false otherwise</returns>
|
|
internal static bool IsValidTableName(string TableName)
|
|
{
|
|
if ((String.IsNullOrEmpty(TableName)) ||
|
|
(TableName.Length < 1) ||
|
|
(TableName.Length > 75))
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// For internal use only - Check to see if Version information is valid
|
|
/// </summary>
|
|
/// <param name="VersionInformation">Version Information for a table</param>
|
|
/// <returns>true if valid logistically, false otherwise</returns>
|
|
internal static bool IsValidVersionInformation(string VersionInformation)
|
|
{
|
|
bool bIsValid = (!String.IsNullOrEmpty(VersionInformation) && (VersionInformation.Length == 8));
|
|
if (bIsValid)
|
|
{
|
|
string[] versionEntities = VersionInformation.Split('.');
|
|
bIsValid = (versionEntities.Length == 3);
|
|
}
|
|
return (bIsValid);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper Classes
|
|
/// </summary>
|
|
public class DataTypeHelpers
|
|
{
|
|
/// <summary>
|
|
/// Many Artifact Checking Functions (Except for Insert/modify) Only need the location,
|
|
/// So if you have a location, use this function to create a quick Artifact to use in those
|
|
/// checking functions
|
|
/// </summary>
|
|
/// <param name="location"></param>
|
|
/// <returns></returns>
|
|
public static ArtifactItem CreateLocationOnlyArtifact(string location)
|
|
{
|
|
ArtifactItem artifactItem = new ArtifactItem()
|
|
{
|
|
Location = location
|
|
};
|
|
return artifactItem;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to create an empty ArtifactItemGroup (should only be used internally)
|
|
/// </summary>
|
|
/// <returns>An Empty ArtifactItemGroups</returns>
|
|
internal static ArtifactItem[] EmptyArtifactItemGroup()
|
|
{
|
|
ArtifactItem[] artifactItems = new ArtifactItem[] { new ArtifactItem() { Location = "" } };
|
|
return artifactItems;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to create an empty WorkspaceItemGroup (should only be used internally)
|
|
/// </summary>
|
|
/// <returns>An Empty WorkspaceItemGroups</returns>
|
|
internal static WorkspaceItem[] EmptyWorkspaceItemGroup()
|
|
{
|
|
WorkspaceItem[] workspaceItems = new WorkspaceItem[] { new WorkspaceItem() { Name = "" } };
|
|
return workspaceItems;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this class for some of our Workspace Methods. Holds Workspace Information as well
|
|
/// as performs Validation.
|
|
/// </summary>
|
|
public class WorkspaceItem
|
|
{
|
|
public string Name { get; set; }
|
|
public DateTime LastAccessed { get; private set; }
|
|
public int AccessCounter { get; set; }
|
|
|
|
// Needed to make sure that dateTime is within limits of SQL,
|
|
// Otherwise SQL stmt may generate an error
|
|
public bool SetLastAccessed(DateTime dateTime)
|
|
{
|
|
if (dateTime >= SqlDateTime.MinValue.Value &&
|
|
dateTime <= SqlDateTime.MaxValue.Value)
|
|
{
|
|
LastAccessed = dateTime;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// *Custom Tag Property * To be used by Callers to tag the object
|
|
public string Tag { get; set; }
|
|
|
|
// default
|
|
public WorkspaceItem()
|
|
{
|
|
Name = "";
|
|
LastAccessed = SqlDateTime.MinValue.Value;
|
|
AccessCounter = 0;
|
|
|
|
// Tag
|
|
Tag = "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs basic Type Validity Tests
|
|
/// </summary>
|
|
public bool IsValid
|
|
{
|
|
get
|
|
{
|
|
if ((Name.Length > 1) &&
|
|
(Name.Length <= 75) &&
|
|
(AccessCounter >= 0) &&
|
|
(LastAccessed != SqlDateTime.MinValue.Value)
|
|
)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region ICloneable Members
|
|
public object Clone()
|
|
{
|
|
return this.MemberwiseClone();
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this Class for all our Artifact Methods. Holds Artifact Information as well
|
|
/// as performs Validation. Use IsValidFileIntegrity() for IO validation
|
|
/// </summary>
|
|
public class ArtifactItem : ICloneable
|
|
{
|
|
public String Name { get; set; }
|
|
public ArtifactTypes Type { get; set; }
|
|
public String Location { get; set; }
|
|
public String Note { get; set; }
|
|
public String SnapshotFile { get; set; }
|
|
public DateTime LastAccessed { get; private set; }
|
|
public int AccessCounter { get; set; }
|
|
|
|
// Needed to make sure that dateTime is within limits of SQL,
|
|
// Otherwise SQL stmt may generate an error
|
|
public bool SetLastAccessed(DateTime dateTime)
|
|
{
|
|
if (dateTime >= SqlDateTime.MinValue.Value &&
|
|
dateTime <= SqlDateTime.MaxValue.Value)
|
|
{
|
|
LastAccessed = dateTime;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// default
|
|
public ArtifactItem()
|
|
{
|
|
SetAsFileType();
|
|
Name = "";
|
|
Location = "";
|
|
Note = "";
|
|
SnapshotFile = "";
|
|
|
|
// LinkProperties
|
|
WindowTop = 0;
|
|
WindowLeft = 0;
|
|
WindowHeight = 0;
|
|
WindowWidth = 0;
|
|
|
|
// Access properties
|
|
LastAccessed = SqlDateTime.MinValue.Value;
|
|
AccessCounter = 0;
|
|
|
|
// Tag
|
|
Tag = "";
|
|
}
|
|
|
|
// Type Check
|
|
public bool IsUrl { get { return Type == ArtifactTypes.Url; } }
|
|
public bool IsFile { get { return Type == ArtifactTypes.File; } }
|
|
|
|
// Type Helpers
|
|
public string FileName
|
|
{
|
|
get
|
|
{
|
|
if (IsFile)
|
|
{
|
|
int nIndex = Location.LastIndexOf('\\');
|
|
if (nIndex > 0 && nIndex < Location.Length)
|
|
return Location.Substring((nIndex + 1));
|
|
}
|
|
return String.Empty;
|
|
}
|
|
}
|
|
public string FileLocation
|
|
{
|
|
get
|
|
{
|
|
if (IsFile)
|
|
{
|
|
int nIndex = Location.LastIndexOf('\\');
|
|
if (nIndex > 0 && nIndex < Location.Length)
|
|
return Location.Substring(0,nIndex);
|
|
}
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
// Type Setting
|
|
public void SetAsFileType() { Type = ArtifactTypes.File; }
|
|
public void SetAsUrlType() { Type = ArtifactTypes.Url; }
|
|
public bool SetType(string strType)
|
|
{
|
|
if (strType.ToUpper() == "FILE")
|
|
{
|
|
SetAsFileType();
|
|
return true;
|
|
}
|
|
else if (strType.ToUpper() == "URL")
|
|
{
|
|
SetAsUrlType();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Setters
|
|
public bool SetFile(string fileNameAndLocation)
|
|
{
|
|
if ((fileNameAndLocation.Length > 1) && File.Exists(fileNameAndLocation))
|
|
{
|
|
SetAsFileType();
|
|
Location = fileNameAndLocation;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
public bool SetUrl(string Url)
|
|
{
|
|
if ((Url.Length > 1)) // To Do - Better Url Checking
|
|
{
|
|
SetAsUrlType();
|
|
Location = Url;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// *Custom Tag Property * To be used by Callers to tag the object
|
|
public string Tag { get; set; }
|
|
|
|
/// <summary>
|
|
/// This Information is used by the link in the Workspace.
|
|
/// ~This information is only filed in the artifact when being retrieved
|
|
/// from a workspace which has link information
|
|
/// </summary>
|
|
public int WindowTop { get; set; }
|
|
public int WindowLeft { get; set; }
|
|
public int WindowHeight { get; set; }
|
|
public int WindowWidth { get; set; }
|
|
|
|
/// <summary>
|
|
/// Use this function to do proper validation of the Link Properties
|
|
/// </summary>
|
|
public bool AreWorkspaceLinkPropertiesValid
|
|
{
|
|
get
|
|
{
|
|
if ((WindowHeight > 0) &&
|
|
(WindowWidth > 0))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs basic Type Validity Tests
|
|
/// </summary>
|
|
public bool IsValid
|
|
{
|
|
get
|
|
{
|
|
if((Name.Length > 1) &&
|
|
(Name.Length <= 150) &&
|
|
(Location.Length > 1) &&
|
|
(Location.Length <= 300) &&
|
|
(Note.Length <= 3000) &&
|
|
(SnapshotFile.Length > 1) &&
|
|
(SnapshotFile.Length <= 300) &&
|
|
(AccessCounter >= 0) //&&
|
|
//(LastAccessed != SqlDateTime.MinValue.Value)
|
|
)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Since Artifact Location is our main source of determining
|
|
/// existence (this provides an easy check only for valid location)
|
|
/// </summary>
|
|
public bool IsLocationValid
|
|
{
|
|
get
|
|
{
|
|
if ((Location.Length > 1) &&
|
|
(Location.Length <= 300))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs Advanced File Validity Tests
|
|
/// </summary>
|
|
public bool IsValidFileIntegrity
|
|
{
|
|
get
|
|
{
|
|
if (IsFile && !File.Exists(Location))
|
|
return false;
|
|
|
|
// To Do * Check if is Valid Url *
|
|
|
|
if (!File.Exists(SnapshotFile))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
#region ICloneable Members
|
|
public object Clone()
|
|
{
|
|
return this.MemberwiseClone();
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
}
|