/// <summary>
/// Deletes a directory specified in the MDirectoryProfile in the current directory.
/// </summary>
/// <param name="currentDirectoryName">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns></returns>
public static string DeleteDirectory(string currentDirectoryName, MDirectoryProfile directoryProfile)
{
if (directoryProfile == null)
{
throw new ArgumentNullException("directoryProfile", "directoryProfile can not be null reference (Nothing in Visual Basic)");
}
string mRetVal = null;
WindowsImpersonationContext mImpersonatedUser = null;
mRetVal = "Successfully deleted the directory(s)";
try
{
if (directoryProfile.Impersonate)
{
mImpersonatedUser = WebImpersonate.ImpersonateNow(directoryProfile.ImpersonateAccount, directoryProfile.ImpersonatePassword);
}
Directory.Delete(currentDirectoryName);
}
catch (IOException ex)
{
mRetVal = ex.Message.ToString();
}
finally
{
if (directoryProfile.Impersonate)
{
// Stop impersonating the user.
if ((mImpersonatedUser != null))
{
mImpersonatedUser.Undo();
}
}
}
return(mRetVal);
}
/// <summary>
/// Saves the specified profile.
/// </summary>
/// <param name="profile">The profile.</param>
public void Save(MDirectoryProfile profile)
{
if (DatabaseIsOnline())
{
m_DDirectories.Save(profile);
}
}
private void populateDirectoryInformation()
{
MDirectoryProfile mProfile = DirectoryUtility.GetProfile(m_Profile.Id);
if (mProfile == null)
{
mProfile = new MDirectoryProfile();
}
txtDirectory.Text = mProfile.Directory;
chkImpersonation.Checked = mProfile.Impersonate;
txtAccount.Text = mProfile.ImpersonateAccount;
txtPassword.Text = mProfile.ImpersonatePassword;
txtHidPwd.Text = mProfile.ImpersonatePassword;
}
/// <summary>
/// Saves the specified profile.
/// </summary>
/// <param name="profile">The profile.</param>
public static void Save(MDirectoryProfile profile)
{
if (profile == null)
{
throw new ArgumentNullException("profile", "profile cannot be a null reference (Nothing in Visual Basic)!");
}
CacheController.RemoveFromCache(s_DirectoryInfoCachedName);
MSecurityEntityProfile mSecurityEntityProfile = SecurityEntityUtility.CurrentProfile();
Logger mLog = Logger.Instance();
try
{
profile.ImpersonatePassword = CryptoUtility.Decrypt(profile.ImpersonatePassword, mSecurityEntityProfile.EncryptionType);
}
catch (CryptoUtilityException)
{
profile.ImpersonatePassword = CryptoUtility.Encrypt(profile.ImpersonatePassword, mSecurityEntityProfile.EncryptionType);
}
try
{
profile.Directory = CryptoUtility.Decrypt(profile.Directory, mSecurityEntityProfile.EncryptionType);
}
catch (CryptoUtilityException)
{
profile.Directory = CryptoUtility.Encrypt(profile.Directory, mSecurityEntityProfile.EncryptionType);
}
try
{
profile.ImpersonateAccount = CryptoUtility.Decrypt(profile.ImpersonateAccount, mSecurityEntityProfile.EncryptionType);
}
catch (CryptoUtilityException)
{
profile.ImpersonateAccount = CryptoUtility.Encrypt(profile.ImpersonateAccount, mSecurityEntityProfile.EncryptionType);
}
BDirectories myBLL = new BDirectories(mSecurityEntityProfile, ConfigSettings.CentralManagement);
try
{
myBLL.Save(profile);
}
catch (DataAccessLayerException ex)
{
mLog.Error(ex);
throw new WebSupportException("Could not save the directory information!");
}
String mCacheName = mSecurityEntityProfile.Id.ToString(CultureInfo.CurrentCulture) + "_" + s_DirectoryInfoCachedName;
CacheController.RemoveFromCache(mCacheName);
}
/// <summary>
/// Gets the directories.
/// </summary>
/// <returns>Collection{MDirectoryProfile}.</returns>
public Collection <MDirectoryProfile> Directories()
{
Collection <MDirectoryProfile> mRetVal = new Collection <MDirectoryProfile>();
if (DatabaseIsOnline())
{
DataTable mDataTable = m_DDirectories.Directories();
foreach (DataRow mDataRow in mDataTable.Rows)
{
MDirectoryProfile mProfile = new MDirectoryProfile(mDataRow);
mRetVal.Add(mProfile);
}
}
return(mRetVal);
}
public IHttpActionResult DeleteFiles(List <UIFileInfo> filesToDelete)
{
HttpServerUtility mServer = HttpContext.Current.Server;
string mRetVal = "Done";
MDirectoryProfile mDirectoryProfile = DirectoryUtility.GetProfile(filesToDelete[0].FunctionSeqId);
bool mExitLoop = false;
foreach (UIFileInfo item in filesToDelete)
{
string mCurrentDirectory = mServer.UrlDecode(item.CurrentDirectory);
if (mCurrentDirectory.Length == 0)
{
mCurrentDirectory = mDirectoryProfile.Directory;
}
else
{
mCurrentDirectory = mDirectoryProfile.Directory + mCurrentDirectory;
}
switch (item.FileType)
{
case "File":
string mFileName = mCurrentDirectory += "/" + mServer.UrlDecode(item.FileName);
mRetVal = FileUtility.DeleteFile(mFileName, mDirectoryProfile);
if (mRetVal.IndexOf("Successfully") == -1)
{
mExitLoop = true;
}
break;
case "Folder":
mCurrentDirectory += "/" + mServer.UrlDecode(item.FileName);
mRetVal = FileUtility.DeleteDirectory(mCurrentDirectory, mDirectoryProfile);
if (mRetVal.IndexOf("Successfully") == -1)
{
mExitLoop = true;
}
break;
default:
break;
}
if (mExitLoop)
{
break;
}
}
return(this.Ok(mRetVal));
}
protected void Page_Load(object sender, EventArgs e)
{
SearchControl.ShowAddLink = false;
MDirectoryProfile mDirectoryProfile = DirectoryUtility.GetProfile(FunctionUtility.CurrentProfile().Id);
String mLinks = FileUtility.GetDirectoryLinks("/", mDirectoryProfile.FunctionSeqId);
directorySelector.InnerHtml = mLinks;
MFunctionProfile mFunctionProfile = FunctionUtility.CurrentProfile();
MAccountProfile mAccountProfile = AccountUtility.CurrentProfile();
MSecurityInfo mSI = new MSecurityInfo(mFunctionProfile, mAccountProfile);
UploadControl.Visible = mSI.MayAdd;
tdNewDirectory.Visible = mSI.MayAdd;
SearchControl.ShowDeleteAll = mSI.MayDelete;
SearchControl.ShowSelect = mSI.MayDelete;
}
void IDDirectories.Save(MDirectoryProfile profile)
{
if (profile == null)
{
throw new ArgumentNullException("profile", "profile cannot be a null reference (Nothing in Visual Basic)!");
}
String mStoredProcedure = "ZGWOptional.Set_Directory";
SqlParameter[] mParameters =
{
new SqlParameter("@P_Function_SeqID", profile.FunctionSeqId),
new SqlParameter("@P_Directory", profile.Directory),
new SqlParameter("@P_Impersonate", profile.Impersonate),
new SqlParameter("@P_Impersonating_Account", profile.ImpersonateAccount),
new SqlParameter("@P_Impersonating_Password", profile.ImpersonatePassword),
new SqlParameter("@P_Added_Updated_By", GetAddedUpdatedBy(profile)),
GetSqlParameter("@P_Primary_Key", -1, ParameterDirection.Output)
};
base.ExecuteNonQuery(mStoredProcedure, mParameters);
}
/// <summary>
/// Gets the profile.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>MDirectoryProfile.</returns>
public static MDirectoryProfile GetProfile(int id)
{
var mResult = from mProfile in Directories()
where mProfile.Id == id
select mProfile;
MDirectoryProfile mRetVal = null;
try
{
mRetVal = mResult.First();
}
catch (NullReferenceException)
{
mRetVal = null;
}
catch (InvalidOperationException)
{
return(null);
}
return(mRetVal);
}
/// <summary>
/// Gets the profile.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>MDirectoryProfile.</returns>
public static MDirectoryProfile GetProfile(String name)
{
var mResult = from mProfile in Directories()
where mProfile.Name.ToLower(CultureInfo.CurrentCulture) == name.ToLower(CultureInfo.CurrentCulture)
select mProfile;
MDirectoryProfile mRetVal = null;
try
{
mRetVal = mResult.First();
}
catch (NullReferenceException)
{
mRetVal = null;
}
catch (InvalidOperationException)
{
return(null);
}
return(mRetVal);
}
/// <summary>
/// Binds the data.
/// </summary>
/// <param name="searchCriteria">The search criteria.</param>
private void bindData(MSearchCriteria searchCriteria)
{
try
{
HttpServerUtility mServer = Server;
string mAction = GWWebHelper.GetQueryValue(HttpContext.Current.Request, "Action");
MFunctionProfile mFunctionProfile = FunctionUtility.GetProfile(mAction);
m_DirectoryProfile = DirectoryUtility.GetProfileByFunction(mFunctionProfile.Id);
string mDirectoryPath = m_DirectoryProfile.Directory + m_CurrentDirectory;
DataTable mDataTable = FileUtility.GetDirectoryTableData(mDirectoryPath, m_DirectoryProfile, false);
SortTable mSorter = new SortTable();
string mColName = searchCriteria.OrderByColumn;
mSorter.Sort(mDataTable, mColName, searchCriteria.OrderByDirection);
DataView mView = mDataTable.DefaultView;
mView.Sort = "type desc";
mDataTable = DataHelper.GetTable(ref mView);
//mDataTable = DataHelper.GetPageOfData(ref mDataTable, ref searchCriteria);
string mSort = "type desc, " + searchCriteria.OrderByColumn + " " + searchCriteria.OrderByDirection;
mDataTable = DataHelper.GetPageOfData(ref mDataTable, mSort, searchCriteria);
if (mDataTable != null && mDataTable.Rows.Count > 0)
{
DataView mDataView = mDataTable.DefaultView;
recordsReturned.Value = mDataTable.Rows[0][DataHelper.TotalRowColumnName].ToString();
searchResults.DataSource = mDataTable;
searchResults.DataBind();
}
else
{
noResults.Visible = true;
}
}
catch (DirectoryNotFoundException)
{
litErrorMSG.Visible = true;
litErrorMSG.Text = "The Directory has not been setup or is unavalible.";
}
}
public IHttpActionResult CreateDirectory([FromUri()] string currentDirectoryString, [FromUri()] int functionSeqId, [FromUri()] string newDirectory)
{
string mRetVal = "Unable to create directory";
if (String.IsNullOrEmpty(currentDirectoryString) || String.IsNullOrEmpty(newDirectory))
{
mRetVal = "All parameters must be passed!";
ArgumentException ex = new ArgumentException(mRetVal);
Logger mLog = Logger.Instance();
mLog.Error(mRetVal);
throw (ex);
}
HttpServerUtility mServer = HttpContext.Current.Server;
MDirectoryProfile mDirectoryProfile = DirectoryUtility.GetProfile(functionSeqId);
String mCurrentDirectory = mDirectoryProfile.Directory;
if (currentDirectoryString.Length > 0)
{
mCurrentDirectory += @"\" + currentDirectoryString;
}
mRetVal = FileUtility.CreateDirectory(mServer.UrlDecode(mCurrentDirectory), mServer.UrlDecode(newDirectory), mDirectoryProfile);
return(this.Ok(mRetVal));
}
/// <summary>
/// Enables processing of HTTP Web requests for downloading files that implements the <see cref="T:System.Web.IHttpHandler" /> interface.
/// </summary>
/// <param name="context">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
public void ProcessRequest(HttpContext context)
{
String mFilename = GWWebHelper.GetQueryValue(context.Request, "fileName");
String mPath = GWWebHelper.GetQueryValue(context.Request, "thePath");
String mFunctionSeqIDString = GWWebHelper.GetQueryValue(context.Request, "functionSeqID");
if (!String.IsNullOrEmpty(mFilename) && !String.IsNullOrEmpty(mFunctionSeqIDString) && !String.IsNullOrEmpty(mPath))
{
int mFunctionSeqID = int.Parse(mFunctionSeqIDString);
MDirectoryProfile mDirectoryProfile = DirectoryUtility.GetProfile(mFunctionSeqID);
context.Response.ContentType = "application/octet-stream";
context.Response.AddHeader("Content-Disposition", string.Format("attachment; filename=\"{0}\"", mFilename));
using (Stream s = new FileStream(mDirectoryProfile.Directory + mPath + "/" + mFilename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
s.CopyTo(context.Response.OutputStream);
}
}
else
{
context.Response.ContentType = "text/plain";
context.Response.Write("Invalid filename");
}
}
/// <summary>
/// Returns a table of files and directories.
/// </summary>
/// <param name="path">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns>DataTable</returns>
public static DataTable GetDirectoryTableData(string path, MDirectoryProfile directoryProfile)
{
return(GetDirectoryTableData(path, directoryProfile, false));
}
private void populatePage()
{
litSecurityEntity.Text = m_Profile.Name;
txtSecurityEntity.Text = m_Profile.Name;
if (m_Profile.Id == -1)
{
litSecurityEntity.Visible = false;
txtSecurityEntity.Style.Add("display", "");
}
else
{
litSecurityEntity.Visible = true;
txtSecurityEntity.Style.Add("display", "none");
}
txtSeqID.Text = m_Profile.Id.ToString();
txtDescription.Text = m_Profile.Description;
txtURL.Text = m_Profile.Url;
try
{
txtConnectionstring.Text = CryptoUtility.Decrypt(m_Profile.ConnectionString, SecurityEntityUtility.CurrentProfile().EncryptionType);
}
catch (Exception)
{
txtConnectionstring.Text = m_Profile.ConnectionString;
}
litSecurityEntityTranslation.Text = ConfigSettings.SecurityEntityTranslation;
txtAssembly_Name.Text = m_Profile.DataAccessLayerAssemblyName;
txtName_Space.Text = m_Profile.DataAccessLayerNamespace;
MDirectoryProfile myDirectoryInfo = new MDirectoryProfile();
DataView dvSkin = new DataView();
dvSkin = FileUtility.GetDirectoryTableData(GWWebHelper.SkinPath, myDirectoryInfo, false).DefaultView;
dvSkin.RowFilter = "Type = 'folder'";
dropSkin.DataSource = dvSkin;
dropSkin.DataTextField = "Name";
dropSkin.DataValueField = "Name";
dropSkin.DataBind();
DataView dvStyles = new DataView();
dvStyles = FileUtility.GetDirectoryTableData(Server.MapPath(@"~\Content\FormStyles"), myDirectoryInfo, true).DefaultView;
dvStyles.RowFilter = "[Name] like '%.css'";
dropStyles.DataSource = dvStyles;
dropStyles.DataTextField = "ShortFileName";
dropStyles.DataValueField = "ShortFileName";
dropStyles.DataBind();
Collection <MSecurityEntityProfile> mProfiles = SecurityEntityUtility.Profiles();
dropParent.DataSource = mProfiles;
MSecurityEntityProfile mm = new MSecurityEntityProfile();
dropParent.DataTextField = "Name";
dropParent.DataValueField = "Id";
dropParent.DataBind();
ListItem lstItem = new ListItem();
lstItem.Text = "None";
lstItem.Value = "-1";
dropParent.Items.Add(lstItem);
NameValuePairUtility.SetDropSelection(dropParent, m_Profile.ParentSeqId.ToString());
NameValuePairUtility.SetDropSelection(dropSkin, m_Profile.Skin);
NameValuePairUtility.SetDropSelection(dropStyles, m_Profile.Style);
NameValuePairUtility.SetDropSelection(dropStatus, m_Profile.StatusSeqId.ToString());
NameValuePairUtility.SetDropSelection(dropDAL, m_Profile.DataAccessLayer);
NameValuePairUtility.SetDropSelection(dropEncryptionType, m_Profile.EncryptionType.ToString());
}
/// <summary>
/// Returns a table of files and/or directories.
/// </summary>
/// <param name="path">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <param name="filesOnly">bool</param>
/// <returns>DataTable sorted by the "Name" column ascending</returns>
public static DataTable GetDirectoryTableData(string path, MDirectoryProfile directoryProfile, bool filesOnly)
{
return(GetDirectoryTableData(path, directoryProfile, filesOnly, "Name", "ASC"));
}
//http://osman.it/aspnet/jquery-ajax-file-upload/
public void ProcessRequest(HttpContext context)
{
string mResponse = "Success";
try
{
string mAction = GWWebHelper.GetQueryValue(context.Request, "Action");
string mCurrentDirectory = GWWebHelper.GetQueryValue(context.Request, "CurrentDirectory");
MFunctionProfile mFunctionProfile = FunctionUtility.GetProfile(mAction);
MDirectoryProfile mDirectoryInfo = DirectoryUtility.GetProfileByFunction(mFunctionProfile.Id);
string mDirectory = mDirectoryInfo.Directory;
if (!string.IsNullOrEmpty(mCurrentDirectory))
{
if (mDirectory.LastIndexOf(Path.DirectorySeparatorChar) != mDirectory.Length)
{
mDirectory += Path.DirectorySeparatorChar + mCurrentDirectory;
}
}
string mUploadDirectory = "";
try
{
mUploadDirectory = context.Request.Files.AllKeys[0].ToString().Substring(0, context.Request.Files.AllKeys[0].LastIndexOf("."));
}
catch (Exception)
{
mUploadDirectory = context.Request["fileName"].ToString();
mUploadDirectory = mUploadDirectory.Substring(0, mUploadDirectory.LastIndexOf("."));
mUploadDirectory = Path.DirectorySeparatorChar + mUploadDirectory;
}
if (!Directory.Exists(mUploadDirectory))
{
FileUtility.CreateDirectory(mDirectory, mUploadDirectory, mDirectoryInfo);
}
mUploadDirectory = mDirectory + Path.DirectorySeparatorChar + mUploadDirectory;
if (context.Request["completed"] == null)
{
if (mDirectoryInfo != null)
{
FileUtility.DoUpload(context.Request.Files.AllKeys[0], context.Request.Files[0], mUploadDirectory, mDirectoryInfo);
if (context.Request["single"] != null)
{
string mFileName = context.Request.Files[0].FileName;
string mNewpath = Path.Combine(mUploadDirectory, mFileName);
FileUtility.RenameFile(mNewpath, mDirectory + mFileName, mDirectoryInfo);
FileUtility.DeleteDirectory(mUploadDirectory, mDirectoryInfo);
}
}
}
else
{
if (context.Request["completed"].ToString().ToLowerInvariant() == "true")
{
string mFileName = context.Request["fileName"].ToString();
string mPath = mUploadDirectory;
string mNewpath = Path.Combine(mPath, mFileName);
char mDirectorySeparatorChar = Path.DirectorySeparatorChar;
if (mDirectoryInfo != null)
{
DataTable mFileTable = FileUtility.GetDirectoryTableData(mUploadDirectory, mDirectoryInfo, true);
SortTable mSorter = new Framework.Common.SortTable();
String mColName = "Name";
mSorter.Sort(mFileTable, mColName, "ASC");
DataView mFiles = mFileTable.DefaultView;
mFiles.RowFilter = "Name like '" + mFileName.Substring(0, mFileName.Length - 4) + "%'";
foreach (DataRowView rowView in mFiles)
{
DataRow row = rowView.Row;
string mPartialFileName = mUploadDirectory + mDirectorySeparatorChar.ToString() + row["Name"].ToString();
if (mPartialFileName.EndsWith("_UploadNumber_1"))
{
if (File.Exists(mNewpath))
{
File.Delete(mNewpath);
}
}
if (mPartialFileName != mNewpath)
{
mergeFiles(mNewpath, mPartialFileName);
}
}
FileUtility.RenameFile(mNewpath, mDirectory + mFileName, mDirectoryInfo);
FileUtility.DeleteDirectory(mUploadDirectory, mDirectoryInfo);
}
}
}
}
catch (Exception ex)
{
Logger mLog = Logger.Instance();
mLog.Error(ex);
mResponse = "Error";
}
context.Response.ContentType = "text/plain";
context.Response.Write(mResponse);
}
public IHttpActionResult Save(UIFunctionProfile uiProfile)
{
if (uiProfile == null)
{
throw new ArgumentNullException("uiProfile", "uiProfile cannot be a null reference (Nothing in Visual Basic)!");
}
string mRetVal = "false";
MSecurityInfo mSecurityInfo = new MSecurityInfo(FunctionUtility.GetProfile(ConfigSettings.GetAppSettingValue("Actions_EditFunction", true)), AccountUtility.CurrentProfile());
Logger mLog = Logger.Instance();
if (HttpContext.Current.Items["EditId"] != null)
{
int mEditId = int.Parse(HttpContext.Current.Items["EditId"].ToString());
if (mEditId == uiProfile.Id)
{
MAccountProfile mAccountProfile = AccountUtility.CurrentProfile();
MFunctionProfile profile = new MFunctionProfile();
MDirectoryProfile directoryProfile = new MDirectoryProfile();
if (uiProfile.Id != -1)
{
if (!mSecurityInfo.MayEdit)
{
Exception mError = new Exception("The account (" + AccountUtility.CurrentProfile().Account + ") being used does not have the correct permissions to edit");
mLog.Error(mError);
return(this.InternalServerError(mError));
}
profile = FunctionUtility.GetProfile(uiProfile.Id);
profile.UpdatedBy = mAccountProfile.Id;
profile.UpdatedDate = DateTime.Now;
}
else
{
if (!mSecurityInfo.MayAdd)
{
Exception mError = new Exception("The account (" + AccountUtility.CurrentProfile().Account + ") being used does not have the correct permissions to add");
mLog.Error(mError);
return(this.InternalServerError(mError));
}
profile.AddedBy = mAccountProfile.Id;
profile.AddedDate = DateTime.Now;
}
string viewCommaRoles = String.Join(",", uiProfile.RolesAndGroups.ViewRoles);
string addCommaRoles = String.Join(",", uiProfile.RolesAndGroups.AddRoles);
string editCommaRoles = String.Join(",", uiProfile.RolesAndGroups.EditRoles);
string deleteCommaRoles = String.Join(",", uiProfile.RolesAndGroups.DeleteRoles);
string viewCommaGroups = String.Join(",", uiProfile.RolesAndGroups.ViewGroups);
string addCommaGroups = String.Join(",", uiProfile.RolesAndGroups.AddGroups);
string editCommaGroups = String.Join(",", uiProfile.RolesAndGroups.EditGroups);
string deleteCommaGroups = String.Join(",", uiProfile.RolesAndGroups.DeleteGroups);
bool saveGroups = false;
bool saveRoles = false;
if (profile.GetCommaSeparatedAssignedRoles(PermissionType.View) != viewCommaRoles)
{
profile.SetAssignedRoles(viewCommaRoles, PermissionType.View);
saveRoles = true;
}
if (profile.GetCommaSeparatedAssignedRoles(PermissionType.Add) != addCommaRoles)
{
profile.SetAssignedRoles(addCommaRoles, PermissionType.Add);
saveRoles = true;
}
if (profile.GetCommaSeparatedAssignedRoles(PermissionType.Edit) != editCommaRoles)
{
profile.SetAssignedRoles(editCommaRoles, PermissionType.Edit);
saveRoles = true;
}
if (profile.GetCommaSeparatedAssignedRoles(PermissionType.Delete) != deleteCommaRoles)
{
profile.SetAssignedRoles(deleteCommaRoles, PermissionType.Delete);
saveRoles = true;
}
if (profile.GetCommaSeparatedGroups(PermissionType.View) != viewCommaGroups)
{
profile.SetGroups(viewCommaGroups, PermissionType.View);
saveGroups = true;
}
if (profile.GetCommaSeparatedGroups(PermissionType.Add) != addCommaGroups)
{
profile.SetGroups(addCommaGroups, PermissionType.Add);
saveGroups = true;
}
if (profile.GetCommaSeparatedGroups(PermissionType.Edit) != editCommaGroups)
{
profile.SetGroups(editCommaGroups, PermissionType.Edit);
saveGroups = true;
}
if (profile.GetCommaSeparatedGroups(PermissionType.Delete) != deleteCommaGroups)
{
profile.SetGroups(deleteCommaGroups, PermissionType.Delete);
saveGroups = true;
}
profile.Action = uiProfile.Action;
profile.EnableNotifications = uiProfile.EnableNotifications;
profile.EnableViewState = uiProfile.EnableViewState;
profile.FunctionTypeSeqId = uiProfile.FunctionTypeSeqID;
profile.Id = uiProfile.Id;
profile.IsNavigable = uiProfile.IsNav;
profile.LinkBehavior = uiProfile.LinkBehavior;
profile.MetaKeywords = uiProfile.MetaKeyWords;
profile.Name = uiProfile.Name;
profile.NavigationTypeSeqId = uiProfile.NavigationTypeSeqId;
profile.Notes = uiProfile.Notes;
profile.NoUI = uiProfile.NoUI;
profile.ParentId = uiProfile.ParentID;
profile.Source = uiProfile.Source;
profile.Description = uiProfile.Description;
profile.RedirectOnTimeout = uiProfile.RedirectOnTimeout;
FunctionUtility.Save(profile, saveGroups, saveRoles);
profile = FunctionUtility.GetProfile(uiProfile.Action);
directoryProfile = DirectoryUtility.GetProfile(profile.Id);
if (!String.IsNullOrEmpty(uiProfile.DirectoryData.Directory))
{
if (directoryProfile == null)
{
directoryProfile = new MDirectoryProfile();
}
directoryProfile.FunctionSeqId = profile.Id;
directoryProfile.Directory = uiProfile.DirectoryData.Directory;
directoryProfile.Impersonate = uiProfile.DirectoryData.Impersonate;
directoryProfile.ImpersonateAccount = uiProfile.DirectoryData.ImpersonateAccount;
directoryProfile.ImpersonatePassword = uiProfile.DirectoryData.ImpersonatePassword;
directoryProfile.Name = uiProfile.DirectoryData.Directory;
directoryProfile.UpdatedBy = mAccountProfile.Id;
DirectoryUtility.Save(directoryProfile);
}
else
{
if (directoryProfile != null)
{
directoryProfile.Directory = "";
directoryProfile.Name = "";
DirectoryUtility.Save(directoryProfile);
}
}
AccountUtility.RemoveInMemoryInformation(true);
mRetVal = "true";
}
else
{
Exception mError = new Exception("Identifier you have last looked at does not match the one passed in nothing has been saved!!!!");
mLog.Error(mError);
return(this.InternalServerError(mError));
}
}
else
{
Exception mError = new Exception("Identifier could not be determined, nothing has been saved!!!!");
mLog.Error(mError);
return(this.InternalServerError(mError));
}
return(Ok(mRetVal));
}
/// <summary>
/// Up loads file from an HtmlInputFile to the directory specified in the MDirectoryProfile object.
/// </summary>
/// <param name="uploadFile">HtmlInputFile</param>
/// <param name="currentDirectory">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns>string</returns>
public static string DoUpload(HttpPostedFile uploadFile, string currentDirectory, MDirectoryProfile directoryProfile)
{
return(DoUpload(null, uploadFile, currentDirectory, directoryProfile));
}
/// <summary>
/// Up loads file from an HtmlInputFile to the directory specified in the MDirectoryProfile object with a specific file name.
/// </summary>
/// <param name="fileName">string</param>
/// <param name="uploadFile">HtmlInputFile</param>
/// <param name="currentDirectory">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns>string</returns>
public static string DoUpload(string fileName, HttpPostedFile uploadFile, string currentDirectory, MDirectoryProfile directoryProfile)
{
if (directoryProfile == null)
{
throw new ArgumentNullException("directoryProfile", "directoryProfile can not be null reference (Nothing in Visual Basic)");
}
string mRetVal = "Upload successfull";
char mDirectorySeparatorChar = System.IO.Path.DirectorySeparatorChar;
WindowsImpersonationContext mImpersonatedUser = null;
if ((uploadFile != null))
{
try
{
if (directoryProfile.Impersonate)
{
mImpersonatedUser = WebImpersonate.ImpersonateNow(directoryProfile.ImpersonateAccount, directoryProfile.ImpersonatePassword);
}
string mFilename = uploadFile.FileName;
if (fileName != null)
{
mFilename = fileName;
}
System.IO.Path.GetFileName(uploadFile.FileName);
uploadFile.SaveAs(currentDirectory + mDirectorySeparatorChar.ToString() + mFilename);
}
catch (IOException ex)
{
Logger mLog = Logger.Instance();
mLog.Error(ex);
mRetVal = "Failed uploading file";
}
finally
{
if (directoryProfile.Impersonate)
{
// Stop impersonating the user.
if ((mImpersonatedUser != null))
{
mImpersonatedUser.Undo();
}
}
}
}
else
{
mRetVal = "fileToUpload cannot be a null reference (Nothing in Visual Basic)! or Nothing.";
}
return(mRetVal);
}
/// <summary>
/// Creates the directory specified in the MDirectoryProfile given the currentDirecty.
/// </summary>
/// <param name="currentDirectory">string</param>
/// <param name="newDirectoryName">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns>string</returns>
public static string CreateDirectory(string currentDirectory, string newDirectoryName, MDirectoryProfile directoryProfile)
{
if (directoryProfile == null)
{
throw new ArgumentNullException("directoryProfile", "directoryProfile can not be null reference (Nothing in Visual Basic)");
}
string mRetVal = null;
mRetVal = "Successfully created the new directory!";
WindowsImpersonationContext impersonatedUser = null;
try
{
if (directoryProfile.Impersonate)
{
impersonatedUser = WebImpersonate.ImpersonateNow(directoryProfile.ImpersonateAccount, directoryProfile.ImpersonatePassword);
}
Directory.CreateDirectory(currentDirectory + "\\" + newDirectoryName);
}
catch (IOException ex)
{
Logger mLog = Logger.Instance();
mLog.Error(ex);
mRetVal = "Directory was not created!";
}
finally
{
if (directoryProfile.Impersonate)
{
// Stop impersonating the user.
if ((impersonatedUser != null))
{
impersonatedUser.Undo();
}
}
}
return(mRetVal);
}
/// <summary>
/// Returns a table of files and/or directories.
/// </summary>
/// <param name="path">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <param name="filesOnly">bool</param>
/// <param name="columnName">name of the column to sort on</param>
/// <param name="sortOrder">the sort direction "ASC" or "DESC"</param>
/// <returns>DataTable</returns>
public static DataTable GetDirectoryTableData(string path, MDirectoryProfile directoryProfile, bool filesOnly, string columnName, string sortOrder)
{
if (directoryProfile == null)
{
throw new ArgumentNullException("directoryProfile", "directoryProfile can not be null reference (Nothing in Visual Basic)");
}
DataTable mRetTable = getDataTable();
DataRow mRow = mRetTable.NewRow();
StringBuilder mStringBuilder = new StringBuilder(4096);
string[] mDirs = null;
char mDirectorySeparatorChar = System.IO.Path.DirectorySeparatorChar;
WindowsImpersonationContext mImpersonatedUser = null;
if (directoryProfile.Impersonate)
{
mImpersonatedUser = WebImpersonate.ImpersonateNow(directoryProfile.ImpersonateAccount, directoryProfile.ImpersonatePassword);
}
mRow["Name"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
if (!filesOnly)
{
try
{
mDirs = Directory.GetDirectories(path);
foreach (string mDirectory in mDirs)
{
string mDirName = System.IO.Path.GetFileName(mDirectory);
mStringBuilder = new StringBuilder();
// Clear the string builder
mRow = mRetTable.NewRow();
// Create a new row
// Populate the string for the new row
mStringBuilder.Append(mDirName);
// Populate the cell in the row
mRow["Name"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
mRow["ShortFileName"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
mRow["Extension"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
// Populate the cell in the row
mRow["Delete"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
mStringBuilder.Append("Folder");
// Populate the cell in the row
mRow["Type"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
mStringBuilder.Append("N/A");
// Populate the cell in the row
mRow["Size"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
// Clear the string builder
mStringBuilder.Append(Directory.GetLastWriteTime(path + mDirectorySeparatorChar.ToString(CultureInfo.InvariantCulture) + mDirName).ToString());
// Populate the cell in the row
mRow["Modified"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append(mDirectorySeparatorChar.ToString(CultureInfo.InvariantCulture) + mDirName + "\\");
mRow["FullName"] = mStringBuilder.ToString();
mRetTable.Rows.Add(mRow);
// Add the row to the table
}
}
catch (IOException ex)
{
if (mRetTable != null)
{
mRetTable.Dispose();
}
Logger mLog = Logger.Instance();
mLog.Error(ex);
throw;
}
}
// Add all of the directories to the table
try
{
DirectoryInfo dirInfo = new DirectoryInfo(path);
FileInfo[] files = null;
files = dirInfo.GetFiles();
//FileInfo mFileInfo = null;
if (mRetTable == null)
{
}
foreach (FileInfo mFileInfo in files)
{
mRow = mRetTable.NewRow();
string mFilename = mFileInfo.Name;
string mShortFileName = mFileInfo.Name;
mShortFileName = mFilename.Remove(mFilename.Length - mFileInfo.Extension.Length, mFileInfo.Extension.Length);
mStringBuilder = new StringBuilder();
mStringBuilder.Append(mFilename);
mRow["Name"] = mFilename.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append("File");
mRow["Type"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append(mShortFileName);
mRow["shortFileName"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
string fileExtension = mFileInfo.Extension;
mStringBuilder.Append(fileExtension);
mRow["Extension"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append(mFileInfo.Length.ToFileSize());
mRow["Size"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append(File.GetLastWriteTime(path + mDirectorySeparatorChar.ToString() + mFileInfo.Name).ToString());
mRow["Modified"] = mStringBuilder.ToString();
mStringBuilder = new StringBuilder();
mStringBuilder.Append(mFileInfo.FullName);
mRow["FullName"] = mStringBuilder.ToString();
mRetTable.Rows.Add(mRow);
}
}
catch (IOException ex)
{
if (mRetTable != null)
{
mRetTable.Dispose();
}
Logger mLog = Logger.Instance();
mLog.Error(ex);
throw;
}
finally
{
if (directoryProfile.Impersonate)
{
// Stop impersonating the user.
if ((mImpersonatedUser != null))
{
mImpersonatedUser.Undo();
}
}
} // Return the table object as the data source
SortTable mSorter = new Framework.Common.SortTable();
String mColName = columnName;
mSorter.Sort(mRetTable, mColName, sortOrder);
return(mRetTable);
}
public static bool AddToCacheDependency(string key, object value)
{
bool retVal = false;
if (!ConfigSettings.CentralManagement & ConfigSettings.EnableCache)
{
FileStream fileStream = null;
string fileName = null;
fileName = s_CacheDirectory + key + ".txt";
// ensure the file exists if not then create one
if (!File.Exists(fileName))
{
try
{
File.Create(fileName).Close();
}
catch (IOException)
{
MDirectoryProfile DirectoryProfile = new MDirectoryProfile();
FileUtility.CreateDirectory(HttpContext.Current.Server.MapPath("~\\"), "CacheDependency", DirectoryProfile);
File.Create(fileName).Close();
}
HttpContext.Current.Application.Lock();
HttpContext.Current.Application[key + "WriteCache"] = true;
HttpContext.Current.Application.UnLock();
}
// re-write the dependancy file based on the application variable
// file replication will cause the other servers to remove their cache item
if (HttpContext.Current.Application[key + "WriteCache"] == null)
{
HttpContext.Current.Application[key + "WriteCache"] = "true";
}
if (Convert.ToBoolean(HttpContext.Current.Application[key + "WriteCache"].ToString(), CultureInfo.InvariantCulture))
{
try
{
fileStream = new FileStream(fileName, FileMode.Truncate);
using (StreamWriter writer = new StreamWriter(fileStream))
{
writer.WriteLine(DateTime.Now.TimeOfDay);
}
HttpContext.Current.Application.Lock();
HttpContext.Current.Application[key + "WriteCache"] = false;
HttpContext.Current.Application.UnLock();
}
catch (Exception)
{
throw;
}
finally
{
if (fileStream != null)
{
fileStream.Dispose();
}
}
}
// cache it for future use
CacheItemRemovedCallback onCacheRemove = null;
CacheDependency mCacheDependency = null;
try
{
onCacheRemove = new CacheItemRemovedCallback(CheckCallback);
mCacheDependency = new CacheDependency(fileName);
if ((value != null))
{
HttpContext.Current.Cache.Add(key, value, mCacheDependency, System.Web.Caching.Cache.NoAbsoluteExpiration, System.Web.Caching.Cache.NoSlidingExpiration, CacheItemPriority.Default, onCacheRemove);
}
}
catch (Exception)
{
throw;
}
finally
{
if (mCacheDependency != null)
{
mCacheDependency.Dispose();
}
}
// used in the orginal vb code and no eq. for the Err object exists in c#
// assume that if no exception has happened the set retVal=true
//if (Err().Number == 0) retVal = true;
retVal = true;
}
else
{
retVal = true;
}
return(retVal);
}
/// <summary>
/// Renames a directory from the "source" to the "destination"
/// </summary>
/// <param name="sourceDirectoryName">string</param>
/// <param name="destinationDirectoryName">string</param>
/// <param name="directoryProfile">MDirectoryProfile</param>
/// <returns>string</returns>
/// <remarks>The MDirectoryProfile object is used for impersonation if necessary.</remarks>
public static string RenameDirectory(string sourceDirectoryName, string destinationDirectoryName, MDirectoryProfile directoryProfile)
{
string mRetVal = null;
WindowsImpersonationContext mImpersonatedUser = null;
mRetVal = "Successfully renamed the directory!";
if (directoryProfile != null)
{
try
{
if (directoryProfile.Impersonate)
{
mImpersonatedUser = WebImpersonate.ImpersonateNow(directoryProfile.ImpersonateAccount, directoryProfile.ImpersonatePassword);
}
Directory.Move(sourceDirectoryName, destinationDirectoryName);
}
catch (IOException ex)
{
Logger mLog = Logger.Instance();
mLog.Error(ex);
mRetVal = ex.Message.ToString();
}
finally
{
if (directoryProfile.Impersonate)
{
// Stop impersonating the user.
if ((mImpersonatedUser != null))
{
mImpersonatedUser.Undo();
}
}
}
}
else
{
throw new ArgumentNullException("directoryProfile", "directoryProfile can not be null reference (Nothing in Visual Basic)");
}
return(mRetVal);
}
