public void TemplateFileInvalidTemplate()
{
MockBuild build = new MockBuild();
TemplateFile tf = new TemplateFile();
tf.BuildEngine = build;
tf.Template = new TaskItem("non_existant_file");
tf.Tokens = GetTaskItems();
Assert.IsFalse(tf.Execute());
Assert.AreEqual(1, build.ErrorCount);
}
public void TemplateFileDefault()
{
MockBuild build = new MockBuild();
TemplateFile tf = new TemplateFile();
tf.BuildEngine = build;
tf.Template = new TaskItem(_templateFilename);
tf.Tokens = GetTaskItems();
Assert.IsTrue(tf.Execute());
Assert.IsNotNull(tf.OutputFile);
Assert.IsTrue(File.Exists(tf.OutputFile.ItemSpec));
_replacedFilename = tf.OutputFile.ItemSpec;
Assert.AreEqual(Path.ChangeExtension(_templateFilename, ".out"), _replacedFilename);
string replaced = File.ReadAllText(tf.OutputFile.ItemSpec);
Assert.AreEqual(_templateReplaced, replaced);
}
public ProjectTemplate(string templateFile)
{
XDocument document = XDocument.Load(templateFile);
TemplateDirectory = Path.GetDirectoryName(templateFile);
var name = document.Root.Attribute("name");
if (name == null)
throw new FileFormatException(Path.GetFileName(templateFile) + " is an invalid project template.");
TemplateName = name.Value;
var icon = document.Root.Attribute("icon");
if (icon == null)
throw new FileFormatException(Path.GetFileName(templateFile) + " is an invalid project template.");
Icon = icon.Value;
if (Path.IsPathRooted(Icon))
Icon = Path.GetFullPath(Icon);
else
Icon = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(templateFile), Icon));
TemplateFiles = new List<TemplateFile>();
foreach (var file in document.Root.Elements("file"))
{
var fileName = file.Attribute("name");
var open = file.Attribute("open");
var focus = file.Attribute("focus");
var template = file.Attribute("template");
var project = file.Attribute("project");
if (fileName == null || template == null)
throw new FileFormatException(Path.GetFileName(templateFile) + " is an invalid project template.");
var tFile = new TemplateFile();
tFile.FileName = fileName.Value;
tFile.Open = tFile.Focused = false;
tFile.Template = template.Value;
if (open != null)
tFile.Open = bool.Parse(open.Value);
if (focus != null)
tFile.Focused = bool.Parse(open.Value);
if (project != null)
tFile.ProjectFile = bool.Parse(project.Value);
TemplateFiles.Add(tFile);
}
}
internal string GenerateViewEdit()
{
TemplateFile template = TemplateFile.LoadTemplate(TemplateType.HTML, Resources.view_Edit);
var instanceEntityName = StringHelper.ConverToInstanceName(CleanEntityName);
var primaryEntityField = Entity.Fields.FirstOrDefault(f => f.IsPrimaryKey);
if (primaryEntityField == null)
{
throw new DataException("Entity [" + Entity.Name + "] doesn't have primary key");
}
TemplateSection sectionForm = template.ExtractSection("FORM");
TemplateSectionCollection propertiesFormList = new TemplateSectionCollection();
foreach (var entityField in Entity.Fields.Where(f => !f.IsPrimaryKey))
{
TemplateSection fieldSection = sectionForm.ExtractSection("FIELD");
fieldSection.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
propertiesFormList.AddSection(fieldSection);
}
template.ReplaceSection("FORM", propertiesFormList);
template.ReplaceTag("PRIMARYKEY_PARAMETERNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("NAMESPACE_MODELS", Settings[AspNetMvcCoreConstants.NAMESPACE_MODELS].Value, false);
template.ReplaceTag("CLASS_NAME_MODEL", ModelClassName, false);
template.ReplaceTag("EDIT_VIEWNAME", Settings[AspNetMvcCoreConstants.EDIT_VIEWNAME].Value, false);
template.ReplaceTag("INDEX_VIEWNAME", Settings[AspNetMvcCoreConstants.INDEX_VIEWNAME].Value, false);
template.ReplaceTag("AUTHOR_NAME", Settings[AspNetMvcCoreConstants.AUTHOR_NAME].Value, false);
template.ReplaceTag("CREATION_DATE", GetSimpleDate(DateTime.Now), false);
return(template.Content);
}
public string GenerateScriptDelete()
{
TemplateFile template = TemplateFile.LoadTemplate(TemplateType.SQL, Resources.sp_Delete);
var primaryEntityField = Entity.Fields.FirstOrDefault(f => f.IsPrimaryKey);
if (primaryEntityField == null)
{
throw new DataException("Entity [" + Entity.Name + "] doesn't have primary key");
}
template.ReplaceTag("PRIMARYKEY_DATATYPE", primaryEntityField.TypeName, false);
template.ReplaceTag("PRIMARYKEY_PARAMETERNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("PRIMARYKEY_PROPERTYNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("DELETE_STORED_PROCEDURE", DeleteStoredProcedureName, false);
template.ReplaceTag("ENTITY_NAME", Entity.Name, false);
template.ReplaceTag("AUTHOR_NAME", Settings[CodeBaseConstants.AUTHOR_NAME].Value, false);
template.ReplaceTag("CREATION_DATE", GetSimpleDate(DateTime.Now), false);
return(template.Content);
}
private TemplateKraftBundle ConstructTmplResBundle(string rootPath, string tmplFolderPath)
{
if (Directory.Exists(tmplFolderPath))
{
TemplateKraftBundle resBundle = new TemplateKraftBundle {
ContentRootPath = rootPath
};
IFileProvider fileProv = new PhysicalFileProvider(tmplFolderPath);
IDirectoryContents dirContents = fileProv.GetDirectoryContents("");
resBundle.StartDirPath = tmplFolderPath;
resBundle.ModuleName = Key;
foreach (IFileInfo file in dirContents)
{
string fileExtension = Path.GetExtension(file.PhysicalPath);
TemplateFile templateFile = new TemplateFile {
TemplateName = file.Name.ToLower().Replace(fileExtension, string.Empty), PhysicalPath = file.PhysicalPath
};
resBundle.TemplateFiles.Add(templateFile);
}
return(resBundle);
}
return(null);
}
private static void createCSharpMonoBehaviour()
{
Debug.Log("Create C# MonoBehaviour");
TemplateFile template = SharpFactory.findTemplate(TemplateType.MonoBehaviour);
if (template == null)
{
return;
}
CreateSharpFileAction endNameEditAction = ScriptableObject.CreateInstance <CreateSharpFileAction>();
endNameEditAction.scriptIcon = EditorIcons.CSharpBehaviourIcon;
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(
0,
endNameEditAction,
"NewMonoBehaviour.cs",
EditorIcons.CSharpBehaviourIcon,
template.getTemplatePath()
);
}
public string GenerateScriptGetById()
{
TemplateFile template = TemplateFile.LoadTemplate(TemplateType.SQL, Resources.sp_GetByID);
TemplateSection sectionSelectColumns = template.ExtractSection("SELECT_COLUMNS");
TemplateSectionCollection selectColumnsSectionList = new TemplateSectionCollection();
foreach (var entityField in Entity.Fields)
{
TemplateSection selectColumnsSection = sectionSelectColumns.ExtractSection("DEFAULT");
selectColumnsSection.ReplaceTag("COLUMNNAME", entityField.ColumnName);
selectColumnsSectionList.AddSection(selectColumnsSection);
}
template.ReplaceSection("SELECT_COLUMNS", selectColumnsSectionList, ",");
var primaryEntityField = Entity.Fields.FirstOrDefault(f => f.IsPrimaryKey);
if (primaryEntityField == null)
{
throw new DataException("Entity [" + Entity.Name + "] doesn't have primary key");
}
template.ReplaceTag("PRIMARYKEY_DATATYPE", primaryEntityField.TypeName, false);
template.ReplaceTag("PRIMARYKEY_PARAMETERNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("PRIMARYKEY_PROPERTYNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("GETBYID_STORED_PROCEDURE", GetByIdStoredProcedureName, false);
template.ReplaceTag("ENTITY_NAME", Entity.Name, false);
template.ReplaceTag("AUTHOR_NAME", Settings[CodeBaseConstants.AUTHOR_NAME].Value, false);
template.ReplaceTag("CREATION_DATE", GetSimpleDate(DateTime.Now), false);
return(template.Content);
}
/// <summary>
/// Загрузить новую версию шаблона
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void loadBtn_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = ".docx | *.docx";
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
ofd.Multiselect = false;
if (File.Exists(ofd.FileName) && templateTypesCB.SelectedItem is TemplateType)
{
byte[] fileBytes;
try
{
fileBytes = File.ReadAllBytes(ofd.FileName);
}
catch (Exception ex)
{
MessageBox.Show($"Ошибка загрузки файла: {ex.Message}");
return;
}
TemplateFile file = new TemplateFile
{
FileData = fileBytes,
HashMd5 = Md5Helper.GetMd5Hash(fileBytes),
TemplateType = (templateTypesCB.SelectedItem as TemplateType),
WhoUpload = GlobalSettings.LoginUser
};
_templateRepository.Add(file);
RefreshTemplateData();
}
}
public object GetDynamicParameters()
{
if (TemplateObject != null &&
TemplateObject != templateObject)
{
templateObject = TemplateObject;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
else if (!string.IsNullOrEmpty(TemplateFile) &&
!TemplateFile.Equals(templateFile, StringComparison.OrdinalIgnoreCase))
{
templateFile = TemplateFile;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
else if (!string.IsNullOrEmpty(TemplateUri) &&
!TemplateUri.Equals(templateUri, StringComparison.OrdinalIgnoreCase))
{
templateUri = TemplateUri;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateUri,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateUri,
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
RegisterDynamicParameters(dynamicParameters);
return(dynamicParameters);
}
public override int GetHashCode()
{
return(TemplateFile.ToLower().GetHashCode() ^ SiteID.GetHashCode());
}
public void GetForumGroup()
{
int forumGroupID = ProviderBase.Framework.Utility.GetFormValue <int>("ID", 0);
string templatePrefix = ProviderBase.Framework.Utility.GetFormValue <string>("TemplatePrefix", "");
string templateName = "ForumGroupRepeat.htm";
string templateFinal = "";
if (string.IsNullOrEmpty(templatePrefix))
{
templatePrefix = this.Website.WebsiteTemplatePrefix;
}
if (forumGroupID > 0)
{
ForumGroup forumGroupItem = null;
forumGroupItem = DataProvider.SelectSingleFull(new ForumGroup()
{
ForumGroupID = forumGroupID
}, this.Website.WebsiteConnection.ConnectionString);
if (forumGroupItem?.ForumGroupID > 0)
{
ForumGroupUserRoleLink forumGroupUserRoleLink = null;
forumGroupUserRoleLink = ProviderBase.Data.Providers.DataProvider.SelectSingleUsingDefault <ForumGroupUserRoleLink>(new ForumGroupUserRoleLink()
{
UserRoleTypeID = this.User.UserRoleTypeID,
ForumGroupID = forumGroupItem.ForumGroupID
}, this.Website.WebsiteConnection.ConnectionString, "UserRoleTypeID", "ForumGroupID");
if (forumGroupUserRoleLink?.UserRoleLevelID > 0)
{
TemplateFile templateFileTemp = null;
templateFileTemp = new TemplateFile(templatePrefix + templateName, this.Website.WebsiteTemplateFolder);
templateFileTemp.BindTemplateFileContentRepeat(forumGroupItem);
foreach (ForumArea forumAreaItem in forumGroupItem.ThreadAreaList)
{
int topicCount = 0;
int postCount = 0;
ForumThreadMessage forumThreadMessageNewest = null;
CharacterUser characterUserNewestForumThreadMessage = null;
topicCount = DataProvider.SelectCount <ForumArea, ForumThread>(forumAreaItem, this.Website.WebsiteConnection.ConnectionString);
postCount = DataProvider.SelectCount <ForumArea, ForumThreadMessage>(forumAreaItem, this.Website.WebsiteConnection.ConnectionString);
forumThreadMessageNewest = DataProvider.SelectNewest <ForumArea, ForumThreadMessage>(forumAreaItem, this.Website.WebsiteConnection.ConnectionString);
characterUserNewestForumThreadMessage = DataProvider.SelectSingleFull <CharacterUser>(new CharacterUser()
{
CharacterUserID = forumThreadMessageNewest.CharacterUserID
}, this.Website.WebsiteConnection.ConnectionString);
templateFileTemp.BindTemplateFileContentRepeatItem(new List <object>()
{
forumAreaItem, forumThreadMessageNewest, characterUserNewestForumThreadMessage
});
templateFileTemp.BindTemplateFileContentRepeatItemSingle("$FORUMTHREADCOUNT$", topicCount);
templateFileTemp.BindTemplateFileContentRepeatItemSingle("$FORUMTHREADMESSAGECOUNT$", postCount);
}
templateFinal += templateFileTemp.TemplateFinalise(this.User);
this.AjaxResult.Data.Add(templateFinal);
this.AjaxResult.Message = "Get forum group success";
this.AjaxResult.Status = AjaxResultStatus.Success;
}
else
{
this.AjaxResult.Redirect = Utility.GetRedirect(this.Context, RedirectReason.InvalidPermission);
this.AjaxResult.Status = AjaxResultStatus.Redirect;
}
}
else
{
this.AjaxResult.Message = "No forum group found";
this.AjaxResult.Status = AjaxResultStatus.Failed;
}
}
else
{
this.AjaxResult.Message = "No forum group ID supplied";
this.AjaxResult.Status = AjaxResultStatus.Failed;
}
}
public virtual object GetDynamicParameters()
{
if (BicepUtility.IsBicepFile(TemplateFile))
{
BuildAndUseBicepTemplate();
}
if (!this.IsParameterBound(c => c.SkipTemplateParameterPrompt))
{
// Resolve the static parameter names for this cmdlet:
string[] staticParameterNames = this.GetStaticParameterNames();
if (TemplateObject != null && TemplateObject != templateObject)
{
templateObject = TemplateObject;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateFile) &&
!TemplateFile.Equals(templateFile, StringComparison.OrdinalIgnoreCase))
{
templateFile = TemplateFile;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateUri) &&
!TemplateUri.Equals(templateUri, StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrEmpty(protectedTemplateUri))
{
templateUri = TemplateUri;
}
else
{
templateUri = protectedTemplateUri;
}
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateUri,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateUri,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateSpecId) &&
!TemplateSpecId.Equals(templateSpecId, StringComparison.OrdinalIgnoreCase))
{
templateSpecId = TemplateSpecId;
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(templateSpecId);
if (!resourceIdentifier.ResourceType.Equals("Microsoft.Resources/templateSpecs/versions", StringComparison.OrdinalIgnoreCase))
{
throw new PSArgumentException("No version found in Resource ID");
}
if (!string.IsNullOrEmpty(resourceIdentifier.Subscription) &&
TemplateSpecsClient.SubscriptionId != resourceIdentifier.Subscription)
{
// The template spec is in a different subscription than our default
// context. Force the client to use that subscription:
TemplateSpecsClient.SubscriptionId = resourceIdentifier.Subscription;
}
JObject templateObj = (JObject)null;
try
{
var templateSpecVersion = TemplateSpecsClient.TemplateSpecVersions.Get(
ResourceIdUtility.GetResourceGroupName(templateSpecId),
ResourceIdUtility.GetResourceName(templateSpecId).Split('/')[0],
resourceIdentifier.ResourceName);
if (!(templateSpecVersion.Template is JObject))
{
throw new InvalidOperationException("Unexpected type."); // Sanity check
}
templateObj = (JObject)templateSpecVersion.Template;
}
catch (TemplateSpecsErrorException e)
{
//If the templateSpec resourceID is pointing to a non existant resource
if (e.Response.StatusCode.Equals(HttpStatusCode.NotFound))
{
//By returning null, we are introducing parity in the way templateURI and templateSpecId are validated. Gives a cleaner error message in line with the error message for invalid templateURI
return(null);
}
//Throw for any other error that is not due to a 404 for the template resource.
throw;
}
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
}
RegisterDynamicParameters(dynamicParameters);
return(dynamicParameters);
}
public void TemplateFileMissingToken()
{
MockBuild build = new MockBuild();
TemplateFile tf = new TemplateFile();
tf.BuildEngine = build;
tf.Template = new TaskItem(_templateFilename);
tf.Tokens = GetTaskItemsMissing();
Assert.IsTrue(tf.Execute());
Assert.IsNotNull(tf.OutputFile);
Assert.IsTrue(File.Exists(tf.OutputFile.ItemSpec));
_replacedFilename = tf.OutputFile.ItemSpec;
Assert.AreEqual(Path.ChangeExtension(_templateFilename, ".out"), _replacedFilename);
string replaced = File.ReadAllText(tf.OutputFile.ItemSpec);
string shouldBeReplaced = _template.Replace("${TemplateItem}", "**Item1**").Replace("${CASEInsenSiTiveTest}", "**Item3**");
Assert.AreEqual(shouldBeReplaced, replaced);
}
public void GetForumThread()
{
int forumThreadID = ProviderBase.Framework.Utility.GetFormValue <int>("ID", 0);
int pageCurrent = ProviderBase.Framework.Utility.GetFormValue <int>("PageCurrent", 1);
int pageSize = ProviderBase.Framework.Utility.GetFormValue <int>("PageSize", 10);
string templatePrefix = ProviderBase.Framework.Utility.GetFormValue <string>("TemplatePrefix", "");
string templateName = "ForumThreadRepeat.htm";
string templateFinal = "";
if (string.IsNullOrEmpty(templatePrefix))
{
templatePrefix = this.Website.WebsiteTemplatePrefix;
}
if (forumThreadID > 0)
{
ForumThread forumThreadItem = null;
DataProviderResultFilter paging = null;
paging = new DataProviderResultFilter();
paging.SetPaging(typeof(ForumArea), typeof(List <ForumThread>), pageCurrent, pageSize);
forumThreadItem = DataProvider.SelectSingleFull(new ForumThread()
{
ForumThreadID = forumThreadID
}, this.Website.WebsiteConnection.ConnectionString, paging);
if (forumThreadItem?.ForumThreadID > 0)
{
ForumArea forumAreaItem = null;
forumAreaItem = ProviderBase.Data.Providers.DataProvider.SelectSingle <ForumArea>(new ForumArea()
{
ForumAreaID = forumThreadItem.ForumAreaID
}, this.Website.WebsiteConnection.ConnectionString);
if (forumAreaItem?.ForumAreaID > 0)
{
ForumGroupUserRoleLink forumGroupUserRoleLink = null;
forumGroupUserRoleLink = ProviderBase.Data.Providers.DataProvider.SelectSingleUsingDefault <ForumGroupUserRoleLink>(new ForumGroupUserRoleLink()
{
UserRoleTypeID = this.User.UserRoleTypeID,
ForumGroupID = forumAreaItem.ForumGroupID
}, this.Website.WebsiteConnection.ConnectionString, "UserRoleTypeID", "ForumGroupID");
if (forumGroupUserRoleLink?.UserRoleLevelID > 0)
{
TemplateFile templateFileTemp = null;
ForumThreadView forumThreadView = null;
templateFileTemp = new TemplateFile(templatePrefix + templateName, this.Website.WebsiteTemplateFolder);
forumThreadItem.PageSize = pageSize; // Override page size so BindTemplateFileContentRepeat is correct
templateFileTemp.BindTemplateFileContent(forumAreaItem, "FORUMAREA");
templateFileTemp.BindTemplateFileContent(forumThreadItem);
templateFileTemp.BindTemplateFileContentRepeat(forumThreadItem);
if (forumThreadItem.ThreadMessageList?.Count > 0)
{
PagingItem pagingItem = null;
pagingItem = ProviderBase.Data.Utility.XMLDeseralize <PagingItem>(this.Context.Server.MapPath(@"/Resource/XML/") + "Conquest/ConquestGamingPaging.xml");
templateFileTemp.BindTemplateFileContentRepeatSingle("$PAGING$", Utility.GeneratePaging(pagingItem, forumThreadItem.ThreadMessageList[0].PageCurrent, forumThreadItem.ThreadMessageList[0].PageTotal));
templateFileTemp.BindTemplateFileContentRepeatSingle("$PAGESIZE$", pageSize);
foreach (ForumThreadMessage forumThreadMessageItem in forumThreadItem.ThreadMessageList)
{
CharacterUser characterUser = null;
characterUser = DataProvider.SelectSingleFull <CharacterUser>(new CharacterUser()
{
UserID = forumThreadMessageItem.CharacterUserID
}, this.Website.WebsiteConnection.ConnectionString);
templateFileTemp.BindTemplateFileContentRepeatItem(new List <object>()
{
forumThreadMessageItem, characterUser
});
}
forumThreadView = new ForumThreadView();
forumThreadView.CharacterUserID = this.User.UserID;
forumThreadView.ForumThreadID = forumThreadID;
forumThreadView.CreateDate = DateTime.Now;
forumThreadView.ForumThreadViewID = DataProvider.Insert <ForumThreadView>(forumThreadView, this.Website.WebsiteConnection.ConnectionString);
}
else
{
templateFileTemp.BindTemplateFileContentSingle("$PAGING$", "");
}
templateFinal += templateFileTemp.TemplateFinalise(this.User);
this.AjaxResult.Data.Add(templateFinal);
this.AjaxResult.Message = "Get forum thread success";
this.AjaxResult.Status = AjaxResultStatus.Success;
}
else
{
this.AjaxResult.Redirect = Utility.GetRedirect(this.Context, RedirectReason.InvalidPermission);
this.AjaxResult.Status = AjaxResultStatus.Redirect;
}
}
}
else
{
this.AjaxResult.Message = "No forum thread found";
this.AjaxResult.Status = AjaxResultStatus.Failed;
}
}
else
{
this.AjaxResult.Message = "No forum thread ID supplied";
this.AjaxResult.Status = AjaxResultStatus.Failed;
}
}
public bool CreateFromTemplate(int TemplateDocsID, int ProjectID, int EventID, int?ReportPeriodID)
{
bool result = true;
try
{
TemplateService ts = new TemplateService();
string dir = ConfigurationManager.AppSettings["PhysicalPath"];
string WordDoc = ts.GenerateDocumentFromTemplateName(TemplateDocsID, EventID, ProjectID, dir, ReportPeriodID);
TemplateFile tfile = ts.GetTemplateDocument(TemplateDocsID).TemplateFile;
string virtdir = "files/" + ProjectID.ToString() + "/"; // "files/A" + DateTime.Now.Year.ToString().Substring(2) + ProjectID.ToString() + "/";
dir += virtdir.Replace("/", "\\");
if (!(Directory.Exists(dir)))
{
Directory.CreateDirectory(dir);
}
string fileformat = EventID.ToString() + "_" + ProjectID.ToString() + "_";
int i;
for (i = 1; System.IO.File.Exists(dir + fileformat + i.ToString() + "." + tfile.fileextension); i++)
{
}
System.IO.File.WriteAllText(dir + fileformat + i.ToString() + "." + tfile.fileextension, WordDoc);
ProjectEventDocument docItem = new ProjectEventDocument();
docItem.Author = session.CurrentUser.FirstName + " " + session.CurrentUser.LastName + " " + session.CurrentUser.MiddleName;;
docItem.CreatedDate = DateTime.Now;
docItem.fileextension = tfile.fileextension;
docItem.FileName = fileformat + i.ToString() + "." + tfile.fileextension;
docItem.PhysicalAbsolutePath = dir + fileformat + i.ToString() + "." + tfile.fileextension;
docItem.PhysicalVirtualPath = "\\" + virtdir.Replace("/", "\\") + fileformat + i.ToString() + "." + tfile.fileextension;
docItem.UpdatedDate = docItem.CreatedDate;
docItem.WebVirtualPath = "/" + virtdir + fileformat + i.ToString() + "." + tfile.fileextension;
//docItem.
ProjectEventService pes = new ProjectEventService();
pes.InsertDocument(docItem, EventID);
TemplateDocument tdoc = ts.GetTemplateDocument(TemplateDocsID);
if (tdoc != null)
{
ProjectService projservice = new ProjectService();
//acknowledgement letter - completed project
if (tdoc.TemplateDocName.ToLower().Contains("letter") && tdoc.TemplateDocName.ToLower().Contains("acknowledgement"))
{
AppDropDownsService apservice = new AppDropDownsService();
ProposalStatusList psitem = apservice.ProposalStatusListGetItem("Completed");
//if we have needed status in DB then
if (psitem != null)
{
Project _project = projservice.GetProposalInfo(ProjectID);
ProposalStatus _prop = _project.ProposalStatus;
_prop.PropStatusID = psitem.ProposalStatusID;
projservice.ProposalStatusUpdate(_prop);
}
}
//award letter - Active project
if (tdoc.TemplateDocName.ToLower().Contains("letter") && tdoc.TemplateDocName.ToLower().Contains("award"))
{
AppDropDownsService apservice = new AppDropDownsService();
ProposalStatusList psitem = apservice.ProposalStatusListGetItem("Active");
//if we have needed status in DB then
if (psitem != null)
{
Project _project = projservice.GetProposalInfo(ProjectID);
ProposalStatus _prop = _project.ProposalStatus;
_prop.PropStatusID = psitem.ProposalStatusID;
projservice.ProposalStatusUpdate(_prop);
}
}
//close out letter - Closed project
if (tdoc.TemplateDocName.ToLower().Contains("letter") && tdoc.TemplateDocName.ToLower().Contains("close") && tdoc.TemplateDocName.ToLower().Contains("out"))
{
AppDropDownsService apservice = new AppDropDownsService();
ProposalStatusList psitem = apservice.ProposalStatusListGetItem("Closed");
//if we have needed status in DB then
if (psitem != null)
{
Project _project = projservice.GetProposalInfo(ProjectID);
ProposalStatus _prop = _project.ProposalStatus;
_prop.PropStatusID = psitem.ProposalStatusID;
// projservice.ProposalStatusUpdate(_prop);
}
}
//suspended letter - Active project
if (tdoc.TemplateDocName.ToLower().Contains("letter") && tdoc.TemplateDocName.ToLower().Contains("suspended"))
{
AppDropDownsService apservice = new AppDropDownsService();
ProposalStatusList psitem = apservice.ProposalStatusListGetItem("Suspended");
//if we have needed status in DB then
if (psitem != null)
{
Project _project = projservice.GetProposalInfo(ProjectID);
ProposalStatus _prop = _project.ProposalStatus;
_prop.PropStatusID = psitem.ProposalStatusID;
projservice.ProposalStatusUpdate(_prop);
}
}
//reject letter - Rejected project
if (tdoc.TemplateDocName.ToLower().Contains("letter") && tdoc.TemplateDocName.ToLower().Contains("reject"))
{
AppDropDownsService apservice = new AppDropDownsService();
ProposalStatusList psitem = apservice.ProposalStatusListGetItem("Rejected");
//if we have needed status in DB then
if (psitem != null)
{
Project _project = projservice.GetProposalInfo(ProjectID);
ProposalStatus _prop = _project.ProposalStatus;
_prop.PropStatusID = psitem.ProposalStatusID;
projservice.ProposalStatusUpdate(_prop);
}
}
}
}
catch (Exception ex)
{
result = false;
}
return(result);
}
public object GetDynamicParameters()
{
if (!string.IsNullOrEmpty(GalleryTemplateIdentity))
{
List <PSGalleryItem> galleryItems = new List <PSGalleryItem>();
try
{
galleryItems = GalleryTemplatesClient.FilterGalleryTemplates(new FilterGalleryTemplatesOptions()
{
Identity = GalleryTemplateIdentity
});
}
catch (CloudException)
{
// we could not find a template with that identity
}
if (galleryItems.Count == 0)
{
galleryItems = GalleryTemplatesClient.FilterGalleryTemplates(new FilterGalleryTemplatesOptions()
{
ApplicationName = GalleryTemplateIdentity, AllVersions = false
});
if (galleryItems == null || galleryItems.Count == 0)
{
throw new ArgumentException(string.Format(Properties.Resources.InvalidTemplateIdentity, GalleryTemplateIdentity));
}
GalleryTemplateIdentity = galleryItems[0].Identity;
}
}
if (!string.IsNullOrEmpty(GalleryTemplateIdentity) &&
!GalleryTemplateIdentity.Equals(galleryTemplateName, StringComparison.OrdinalIgnoreCase))
{
galleryTemplateName = GalleryTemplateIdentity;
dynamicParameters = GalleryTemplatesClient.GetTemplateParametersFromGallery(
GalleryTemplateIdentity,
TemplateParameterObject,
this.TryResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else if (!string.IsNullOrEmpty(TemplateFile) &&
!TemplateFile.Equals(templateFile, StringComparison.OrdinalIgnoreCase))
{
templateFile = TemplateFile;
dynamicParameters = GalleryTemplatesClient.GetTemplateParametersFromFile(
this.TryResolvePath(TemplateFile),
TemplateParameterObject,
this.TryResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else if (!string.IsNullOrEmpty(TemplateUri) &&
!TemplateUri.Equals(templateUri, StringComparison.OrdinalIgnoreCase))
{
templateUri = TemplateUri;
dynamicParameters = GalleryTemplatesClient.GetTemplateParametersFromFile(
TemplateUri,
TemplateParameterObject,
this.TryResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
return(dynamicParameters);
}
public string GenerateScriptSave()
{
TemplateFile template = TemplateFile.LoadTemplate(TemplateType.SQL, Resources.sp_Save);
TemplateSection sectionParameters = template.ExtractSection("PARAMETERS");
TemplateSection sectionUpdateParameters = template.ExtractSection("UPDATE_PARAMETERS");
TemplateSection sectionInsertColumns = template.ExtractSection("INSERT_COLUMNS");
TemplateSection sectionInsertParameters = template.ExtractSection("INSERT_PARAMETERS");
TemplateSectionCollection parameterSectionList = new TemplateSectionCollection();
TemplateSectionCollection updateParameterSectionList = new TemplateSectionCollection();
TemplateSectionCollection insertColumnsSectionList = new TemplateSectionCollection();
TemplateSectionCollection insertParameterSectionList = new TemplateSectionCollection();
foreach (var entityField in Entity.Fields)
{
TemplateSection parameterSection = sectionParameters.ExtractSection("DEFAULT");
parameterSection.ReplaceTag("PARAMETERNAME", entityField.ColumnName);
parameterSection.ReplaceTag("DATATYPE", entityField.TypeName);
parameterSectionList.AddSection(parameterSection);
if (!entityField.IsPrimaryKey)
{
TemplateSection updateParameterSection = sectionUpdateParameters.ExtractSection("DEFAULT");
updateParameterSection.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
updateParameterSection.ReplaceTag("PARAMETERNAME", entityField.ColumnName);
updateParameterSectionList.AddSection(updateParameterSection);
TemplateSection insertColumnsSection = sectionInsertColumns.ExtractSection("DEFAULT");
insertColumnsSection.ReplaceTag("COLUMNNAME", entityField.ColumnName);
insertColumnsSectionList.AddSection(insertColumnsSection);
TemplateSection insertParameterSection = sectionInsertParameters.ExtractSection("DEFAULT");
insertParameterSection.ReplaceTag("PARAMETERNAME", entityField.ColumnName);
insertParameterSectionList.AddSection(insertParameterSection);
}
}
template.ReplaceSection("PARAMETERS", parameterSectionList, ",");
template.ReplaceSection("UPDATE_PARAMETERS", updateParameterSectionList, ",");
template.ReplaceSection("INSERT_COLUMNS", insertColumnsSectionList, ",");
template.ReplaceSection("INSERT_PARAMETERS", insertParameterSectionList, ",");
var primaryEntityField = Entity.Fields.FirstOrDefault(f => f.IsPrimaryKey);
if (primaryEntityField == null)
{
throw new DataException("Entity [" + Entity.Name + "] doesn't have primary key");
}
template.ReplaceTag("PRIMARYKEY_DATATYPE", primaryEntityField.TypeName, false);
template.ReplaceTag("PRIMARYKEY_PARAMETERNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("PRIMARYKEY_PROPERTYNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("SAVE_STORED_PROCEDURE", SaveStoredProcedureName, false);
template.ReplaceTag("ENTITY_NAME", Entity.Name, false);
template.ReplaceTag("AUTHOR_NAME", Settings[CodeBaseConstants.AUTHOR_NAME].Value, false);
template.ReplaceTag("CREATION_DATE", GetSimpleDate(DateTime.Now), false);
return(template.Content);
}
public string GenerateCodeDataAccessAsync()
{
TemplateFile template;
string templateType = Settings[CodeBaseConstants.DATAACCESS_TEMPLATE].Value;
if (templateType.Equals("en"))
{
template = TemplateFile.LoadTemplate(TemplateType.CS, Resources.class_DataAccess_async_en);
}
else if (templateType.Equals("es"))
{
template = TemplateFile.LoadTemplate(TemplateType.CS, Resources.class_DataAccess_async_es);
}
else
{
template = TemplateFile.LoadTemplate(TemplateType.CS, Resources.class_DataAccess_async);
}
var primaryEntityField = Entity.Fields.FirstOrDefault(f => f.IsPrimaryKey);
if (primaryEntityField == null)
{
throw new DataException("Entity [" + Entity.Name + "] doesn't have primary key");
}
TemplateSection sectionParameters = template.ExtractSection("PARAMETERS");
TemplateSection sectionParametersAsync = template.ExtractSection("PARAMETERS_ASYNC");
TemplateSection sectionProperties = template.ExtractSection("PROPERTIES");
TemplateSection sectionPropertiesAsync = template.ExtractSection("PROPERTIES_ASYNC");
TemplateSectionCollection sectionParameterList = new TemplateSectionCollection();
TemplateSectionCollection sectionParameterAsyncList = new TemplateSectionCollection();
TemplateSectionCollection sectionPropertyList = new TemplateSectionCollection();
TemplateSectionCollection sectionPropertyAsyncList = new TemplateSectionCollection();
var instanceEntityName = StringHelper.ConverToInstanceName(CleanEntityName);
foreach (var entityField in Entity.Fields)
{
TemplateSection sectionProperty = sectionProperties.ExtractSection(entityField.SimpleTypeName);
sectionProperty.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
sectionProperty.ReplaceTag("COLUMNNAME", entityField.ColumnName);
sectionPropertyList.AddSection(sectionProperty);
TemplateSection sectionPropertyAsync = sectionPropertiesAsync.ExtractSection(entityField.SimpleTypeName);
sectionPropertyAsync.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
sectionPropertyAsync.ReplaceTag("COLUMNNAME", entityField.ColumnName);
sectionPropertyAsyncList.AddSection(sectionPropertyAsync);
TemplateSection sectionParameter = sectionParameters.ExtractSection(entityField.SimpleTypeName);
sectionParameter.ReplaceTag("PARAMETERNAME", entityField.ColumnName);
sectionParameter.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
sectionParameter.ReplaceTag("INSTANCE_NAME_DOMAIN", instanceEntityName, false);
sectionParameterList.AddSection(sectionParameter);
TemplateSection sectionParameterAsync = sectionParametersAsync.ExtractSection(entityField.SimpleTypeName);
sectionParameterAsync.ReplaceTag("PARAMETERNAME", entityField.ColumnName);
sectionParameterAsync.ReplaceTag("PROPERTYNAME", entityField.ColumnName);
sectionParameterAsync.ReplaceTag("INSTANCE_NAME_DOMAIN", instanceEntityName, false);
sectionParameterAsyncList.AddSection(sectionParameterAsync);
}
template.ReplaceSection("PARAMETERS", sectionParameterList);
template.ReplaceSection("PARAMETERS_ASYNC", sectionParameterAsyncList);
template.ReplaceSection("PROPERTIES", sectionPropertyList);
template.ReplaceSection("PROPERTIES_ASYNC", sectionPropertyAsyncList);
template.ReplaceTag("PRIMARYKEY_DATATYPE", DataTypeHelper.GetCSharpType(primaryEntityField.SimpleTypeName), false);
template.ReplaceTag("PRIMARYKEY_PARAMETERNAME", primaryEntityField.ColumnName, false);
template.ReplaceTag("PRIMARYKEY_LOCAL_VARIABLE", StringHelper.ConverToInstanceName(StringHelper.ConvertToSafeCodeName(primaryEntityField.ColumnName)), false);
template.ReplaceTag("NAMESPACE_DOMAIN", Settings[CodeBaseConstants.NAMESPACE_DOMAIN].Value, false);
template.ReplaceTag("NAMESPACE_DATAACCESS", Settings[CodeBaseConstants.NAMESPACE_DATAACCESS].Value, false);
template.ReplaceTag("NAMESPACE_DBHELPER", Settings[CodeBaseConstants.NAMESPACE_DBHELPER].Value, false);
template.ReplaceTag("NAMESPACE_ACCESS_MODEL", Settings[CodeBaseConstants.NAMESPACE_ACCESS_MODEL].Value, false);
template.ReplaceTag("INSTANCE_NAME_DOMAIN", instanceEntityName, false);
template.ReplaceTag("CLASS_NAME_DOMAIN", DomainClassName, false);
template.ReplaceTag("CLASS_NAME_DATAACCESS", DataAccessClassName, false);
template.ReplaceTag("SAVE_STORED_PROCEDURE", SaveStoredProcedureName, false);
template.ReplaceTag("GETBYID_STORED_PROCEDURE", GetByIdStoredProcedureName, false);
template.ReplaceTag("LISTALL_STORED_PROCEDURE", ListAllStoredProcedureName, false);
template.ReplaceTag("DELETE_STORED_PROCEDURE", DeleteStoredProcedureName, false);
template.ReplaceTag("SAVE_METHODNAME", Settings[CodeBaseConstants.SAVE_METHODNAME].Value, false);
template.ReplaceTag("GETBYID_METHODNAME", Settings[CodeBaseConstants.GETBYID_METHODNAME].Value, false);
template.ReplaceTag("LISTALL_METHODNAME", Settings[CodeBaseConstants.LISTALL_METHODNAME].Value, false);
template.ReplaceTag("DELETE_METHODNAME", Settings[CodeBaseConstants.DELETE_METHODNAME].Value, false);
template.ReplaceTag("BUILDFUNCTION_METHODNAME", Settings[CodeBaseConstants.BUILDFUNCTION_METHODNAME].Value, false);
template.ReplaceTag("ASYNC_METHODS_SUFFIX", Settings[CodeBaseConstants.ASYNC_METHODS_SUFFIX].Value, false);
template.ReplaceTag("CONNECTIONSTRING_KEY", Settings[CodeBaseConstants.CONNECTIONSTRING_KEY].Value, false);
template.ReplaceTag("DBHELPER_INSTANCEOBJECT", Settings[CodeBaseConstants.DBHELPER_INSTANCEOBJECT].Value, false);
template.ReplaceTag("GETSCALAR_METHODNAME", Settings[CodeBaseConstants.GETSCALAR_METHODNAME].Value, false);
template.ReplaceTag("GETENTITY_METHODNAME", Settings[CodeBaseConstants.GETENTITY_METHODNAME].Value, false);
template.ReplaceTag("GETDATATABLE_METHODNAME", Settings[CodeBaseConstants.GETDATATABLE_METHODNAME].Value, false);
template.ReplaceTag("EXECUTESP_METHODNAME", Settings[CodeBaseConstants.EXECUTESP_METHODNAME].Value, false);
template.ReplaceTag("GETSCALAR_ASYNC_METHODNAME", Settings[CodeBaseConstants.GETSCALAR_ASYNC_METHODNAME].Value, false);
template.ReplaceTag("GETENTITY_ASYNC_METHODNAME", Settings[CodeBaseConstants.GETENTITY_ASYNC_METHODNAME].Value, false);
template.ReplaceTag("GETDATATABLE_ASYNC_METHODNAME", Settings[CodeBaseConstants.GETDATATABLE_ASYNC_METHODNAME].Value, false);
template.ReplaceTag("EXECUTESP_ASYNC_METHODNAME", Settings[CodeBaseConstants.EXECUTESP_ASYNC_METHODNAME].Value, false);
template.ReplaceTag("AUTHOR_NAME", Settings[CodeBaseConstants.AUTHOR_NAME].Value, false);
template.ReplaceTag("CREATION_DATE", GetSimpleDate(DateTime.Now), false);
return(template.Content);
}
public void Save(TemplateFile entity)
{
//DB LOADING
throw new NotImplementedException();
}
public CodeGenerationContext AddContent(TemplateStandard standard, TemplateFile file, string text)
{
_contents.Add(ContentBase.With(standard, file, _filer, _source, text));
return(this);
}
public object GetDynamicParameters()
{
if (!this.IsParameterBound(c => c.SkipTemplateParameterPrompt))
{
if (TemplateObject != null && TemplateObject != templateObject)
{
templateObject = TemplateObject;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
else if (!string.IsNullOrEmpty(TemplateFile) &&
!TemplateFile.Equals(templateFile, StringComparison.OrdinalIgnoreCase))
{
templateFile = TemplateFile;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
else if (!string.IsNullOrEmpty(TemplateUri) &&
!TemplateUri.Equals(templateUri, StringComparison.OrdinalIgnoreCase))
{
templateUri = TemplateUri;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateUri,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateUri,
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
else if (!string.IsNullOrEmpty(TemplateSpecId) &&
!TemplateSpecId.Equals(templateSpecId, StringComparison.OrdinalIgnoreCase))
{
templateSpecId = TemplateSpecId;
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(templateSpecId);
if (!resourceIdentifier.ResourceType.Equals("Microsoft.Resources/templateSpecs/versions", StringComparison.OrdinalIgnoreCase))
{
throw new PSArgumentException("No version found in Resource ID");
}
var templateSpecVersion = TemplateSpecsSdkClient.GetTemplateSpec(
ResourceIdUtility.GetResourceName(templateSpecId).Split('/')[0],
ResourceIdUtility.GetResourceGroupName(templateSpecId),
resourceIdentifier.ResourceName).Versions.Single();
var templateObj = JObject.Parse(templateSpecVersion.Template);
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
TemplateParameterUri,
MyInvocation.MyCommand.Parameters.Keys.ToArray());
}
}
}
RegisterDynamicParameters(dynamicParameters);
return(dynamicParameters);
}
public bool UpdateTemplateFile(TemplateFile item)
{
return(_rep.UpdateTemplateFile(item));
}
public async Task <ActionResult> OnPostUse()
{
string userEmail = this.HttpContext.User.Identity.Name;
if (string.IsNullOrEmpty(userEmail))
{
return(Redirect("~/login"));
}
this.CurrentUser = context.Set <Models.User>().Where(entry => entry.Email.Equals(userEmail)).FirstOrDefault();
if (this.CurrentUser == null)
{
return(Redirect("~/login"));
}
Dictionary <string, List <object> > subsetDetails = new Dictionary <string, List <object> >()
{
{ "Edu", new List <object>() },
{ "Cert", new List <object>() },
{ "Work", new List <object>() },
{ "Project", new List <object>() },
{ "Skill", new List <object>() },
};
context.Entry(this.CurrentUser).Collection(u => u.UserInfo).Load();
context.Entry(this.CurrentUser).Collection(u => u.CertDetails).Load();
context.Entry(this.CurrentUser).Collection(u => u.EducationDetails).Load();
context.Entry(this.CurrentUser).Collection(u => u.ProjectDetails).Load();
context.Entry(this.CurrentUser).Collection(u => u.SkillDetails).Load();
context.Entry(this.CurrentUser).Collection(u => u.WorkDetails).Load();
foreach (string type in subsetDetails.Keys)
{
int i = 0;
while (true)
{
// this will be null or GUID for type "type"
var str = this.Request.Form[type + i].ToString();
if (string.IsNullOrEmpty(str))
{
break;
}
else
{
foreach (string s in str.Split(","))
{
object addedDetail = null;
switch (type)
{
case "Edu":
addedDetail = this.CurrentUser.EducationDetails.FirstOrDefault(detail => detail.ID.ToString().Equals(s));
break;
case "Cert":
addedDetail = this.CurrentUser.CertDetails.FirstOrDefault(detail => detail.ID.ToString().Equals(s));
break;
case "Work":
addedDetail = this.CurrentUser.WorkDetails.FirstOrDefault(detail => detail.ID.ToString().Equals(s));
break;
case "Project":
addedDetail = this.CurrentUser.ProjectDetails.FirstOrDefault(detail => detail.ID.ToString().Equals(s));
break;
case "Skill":
addedDetail = this.CurrentUser.SkillDetails.FirstOrDefault(detail => detail.ID.ToString().Equals(s));
break;
}
if (addedDetail != null)
{
subsetDetails[type].Add(addedDetail);
}
}
}
i++;
}
}
Template template = context
.Set <Models.Template>()
.Where(temp => temp.ID.ToString().Equals(this.Request.Form["templateId"].ToString()))
.FirstOrDefault();
if (template == null)
{
return(Redirect("~/home"));
}
using (TemplateFile tf = await TemplateFile.Create(this.azureFileController, this.CurrentUser, template.DocumentLink, subsetDetails))
{
// TODO make async, upload to Azure
// TODO write to TemplateUse table
return(File(System.IO.File.ReadAllBytes(tf.LocalFile), "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "Template.docx"));
}
}
public void TemplateFileNewFilename()
{
MockBuild build = new MockBuild();
TemplateFile tf = new TemplateFile();
tf.BuildEngine = build;
tf.Template = new TaskItem(_templateFilename);
string outputfile = Path.Combine(Path.GetDirectoryName(_templateFilename), "Replacement.file");
tf.OutputFilename = outputfile;
tf.Tokens = GetTaskItems();
Assert.IsTrue(tf.Execute());
Assert.IsNotNull(tf.OutputFile);
Assert.IsTrue(File.Exists(tf.OutputFile.ItemSpec));
_replacedFilename = tf.OutputFile.ItemSpec;
Assert.AreEqual(outputfile, _replacedFilename);
string replaced = File.ReadAllText(tf.OutputFile.ItemSpec);
Assert.AreEqual(_templateReplaced, replaced);
}
public List<TemplateFile> Split(string str)
{
var result = new List<TemplateFile>();
MatchCollection collection = CodeBlock.Parse(str, @"(?imsx-n)\$(?<value1>\d)\~(?<value2>.*?)\~\d\$");
foreach (Match item in collection)
{
var f = new TemplateFile();
f.FileId = item.Groups["value1"].Value;
f.Content = item.Groups["value2"].Value.Trim();
result.Add(f);
}
return result;
}
public virtual object GetDynamicParameters()
{
if (!this.IsParameterBound(c => c.SkipTemplateParameterPrompt))
{
// Resolve the static parameter names for this cmdlet:
string[] staticParameterNames = this.GetStaticParameterNames();
if (TemplateObject != null && TemplateObject != templateObject)
{
templateObject = TemplateObject;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
TemplateObject,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateFile) &&
!TemplateFile.Equals(templateFile, StringComparison.OrdinalIgnoreCase))
{
templateFile = TemplateFile;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
this.ResolvePath(TemplateFile),
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateUri) &&
!TemplateUri.Equals(templateUri, StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrEmpty(protectedTemplateUri))
{
templateUri = TemplateUri;
}
else
{
templateUri = protectedTemplateUri;
}
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateUri,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateUri,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
else if (!string.IsNullOrEmpty(TemplateSpecId) &&
!TemplateSpecId.Equals(templateSpecId, StringComparison.OrdinalIgnoreCase))
{
templateSpecId = TemplateSpecId;
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(templateSpecId);
if (!resourceIdentifier.ResourceType.Equals("Microsoft.Resources/templateSpecs/versions", StringComparison.OrdinalIgnoreCase))
{
throw new PSArgumentException("No version found in Resource ID");
}
if (!string.IsNullOrEmpty(resourceIdentifier.Subscription) &&
TemplateSpecsClient.SubscriptionId != resourceIdentifier.Subscription)
{
// The template spec is in a different subscription than our default
// context. Force the client to use that subscription:
TemplateSpecsClient.SubscriptionId = resourceIdentifier.Subscription;
}
var templateSpecVersion = TemplateSpecsClient.TemplateSpecVersions.Get(
ResourceIdUtility.GetResourceGroupName(templateSpecId),
ResourceIdUtility.GetResourceName(templateSpecId).Split('/')[0],
resourceIdentifier.ResourceName);
if (!(templateSpecVersion.Template is JObject))
{
throw new InvalidOperationException("Unexpected type."); // Sanity check
}
JObject templateObj = (JObject)templateSpecVersion.Template;
if (string.IsNullOrEmpty(TemplateParameterUri))
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
this.ResolvePath(TemplateParameterFile),
staticParameterNames);
}
else
{
dynamicParameters = TemplateUtility.GetTemplateParametersFromFile(
templateObj,
TemplateParameterObject,
TemplateParameterUri,
staticParameterNames);
}
}
}
RegisterDynamicParameters(dynamicParameters);
return(dynamicParameters);
}
public TemplateProperties(TemplateFile template)
{
InitializeComponent();
templateFile = template;
}
