/// <summary>
/// 从资源文件读取JSON数据
/// </summary>
/// <param name="project">项目</param>
/// <param name="resourceName">资源名称</param>
/// <returns>Key-Value字典</returns>
private static Dictionary <string, string> ReadProjectJSONResourceFromFile(ProjectTypeEnum project, string resourceName)
{
var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
string jsonFile = reader.ReadToEnd(); //Make string equal to full file
var JsonDictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonFile);
return(JsonDictionary);
}
}
/// <summary>
/// 更新语言资源
/// </summary>
/// <param name="project">项目</param>
/// <param name="jsonResource">语言资源</param>
/// <returns></returns>
internal static bool TryUpdate(ProjectTypeEnum project,
Dictionary <LangTypeEnum, Dictionary <string, string> > jsonResource)
{
var originalResource = GetJsonResource(project);
if (originalResource != null)
{
_lanJsonResourceCache.Set(project, jsonResource);
return(true);
}
return(false);
}
public override Project GetProjectByExternalId(string externalId, ProjectTypeEnum projectType)
{
if (CanFindProjectByExternalId)
{
return(new Project
{
Id = GetProjectIdValue,
ProjectType = projectType,
ExternalId = externalId
});
}
return(null);
}
public ProjectInfoItem(string name, string path, ProjectTypeEnum type = ProjectTypeEnum.Compile)
{
Name = name;
Path = path;
Type = type;
if (type == ProjectTypeEnum.Compile || type == ProjectTypeEnum.Tests)
{
Build = true;
}
Code = Guid.NewGuid().ToString().ToUpperInvariant();
ListChild = new List <string>();
}
public virtual IList <string> GetHeadwordAutocomplete(string queryString, ProjectTypeEnum projectType, BookTypeEnum?bookType,
IList <int> selectedCategoryIds, IList <long> selectedProjectIds, int count, int userId)
{
queryString = EscapeQuery(queryString);
HeadwordResource headwordResourceAlias = null;
Resource resourceAlias = null;
Project projectAlias = null;
Snapshot snapshotAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
var query = GetSession().QueryOver <HeadwordItem>()
.JoinAlias(x => x.HeadwordResource, () => headwordResourceAlias)
.JoinAlias(() => headwordResourceAlias.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => projectAlias.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(() => headwordResourceAlias.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && userAlias.Id == userId && projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.AndRestrictionOn(x => x.Headword).IsLike(queryString, MatchMode.Start)
.Select(Projections.Distinct(Projections.Property <HeadwordItem>(x => x.Headword)))
.OrderBy(x => x.Headword).Asc;
if (bookType != null)
{
query.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookType.Value);
}
if (selectedCategoryIds.Count > 0 || selectedProjectIds.Count > 0)
{
query.JoinAlias(() => projectAlias.Categories, () => categoryAlias, JoinType.LeftOuterJoin)
.Where(Restrictions.Or(
Restrictions.InG(Projections.Property(() => categoryAlias.Id), selectedCategoryIds),
Restrictions.InG(Projections.Property(() => projectAlias.Id), selectedProjectIds)
));
}
return(query
.Take(count)
.List <string>());
}
public FulltextStorageType GetStorageType(ProjectTypeEnum projectType)
{
switch (projectType)
{
case ProjectTypeEnum.Research:
return(FulltextStorageType.ExistDb);
case ProjectTypeEnum.Community:
return(FulltextStorageType.ElasticSearch);
case ProjectTypeEnum.Bibliography:
throw new ArgumentException("Bibliography project doesn't have any text or fulltext storage");
default:
throw new ArgumentOutOfRangeException(nameof(projectType), projectType, null);
}
}
public long UpdateProject(long?projectId, int userId, BookData bookData, ProjectTypeEnum projectType)
{
long projectIdValue;
if (projectId != null)
{
projectIdValue = projectId.Value;
var project = m_projectRepository.FindById <Project>(projectIdValue);
if (project.ExternalId != bookData.BookXmlId)
{
project.ExternalId = bookData.BookXmlId;
project.IsRemoved = false;
m_projectRepository.Update(project);
}
}
else
{
var dbProject = m_projectRepository.GetProjectByExternalId(bookData.BookXmlId, projectType);
if (dbProject != null)
{
projectIdValue = dbProject.Id;
}
else
{
var newProject = new Project
{
Name = bookData.Title,
ProjectType = projectType,
IsRemoved = false,
CreateTime = DateTime.UtcNow,
CreatedByUser = m_projectRepository.Load <User>(userId),
ExternalId = bookData.BookXmlId,
TextType = TextTypeEnum.Transcribed,
Categories = new List <Category>(),
Keywords = new List <Keyword>(),
LiteraryGenres = new List <LiteraryGenre>(),
LiteraryKinds = new List <LiteraryKind>()
};
projectIdValue = (long)m_projectRepository.Create(newProject);
}
}
return(projectIdValue);
}
/// <summary>
/// 读取JSON资源文件
/// </summary>
/// <param name="project">项目</param>
/// <param name="jsonFile">json文件</param>
static void ReadProjectJSONResourceFromFile(ProjectTypeEnum project)
{
var jsonFile = GetJSONFileNameByProject(project);
try
{
var langJsonResource = new Dictionary <LangTypeEnum, Dictionary <string, string> >();
foreach (var item in jsonFile)
{
var jsonResource = ReadProjectJSONResourceFromFile(item.Value);
langJsonResource.Add(item.Key, jsonResource);
}
LanguageCachedHelper.SetJsonResource(project, langJsonResource);
}
catch (System.Exception ex)
{
throw new ApplicationException(string.Format("An error occurred when reading json resource file, detai:{0}", ex.Message), ex);
}
}
public static string TryToStr(this ProjectTypeEnum projectType)
{
string str = string.Empty;
switch (projectType)
{
case ProjectTypeEnum.Big:
str = "大项目";
break;
case ProjectTypeEnum.Secondary:
str = "中项目";
break;
case ProjectTypeEnum.Small:
str = "小项目";
break;
}
return(str);
}
public virtual HeadwordResource GetHeadwordWithFetchByExternalId(string projectExternalId, string headwordExternalId, ProjectTypeEnum projectType)
{
Resource resourceAlias = null;
Project projectAlias = null;
var result = GetSession().QueryOver <HeadwordResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.Where(x => x.ExternalId == headwordExternalId && projectAlias.ExternalId == projectExternalId && projectAlias.ProjectType == projectType && x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved)
.Fetch(SelectMode.Fetch, x => x.Resource)
.Fetch(SelectMode.Fetch, x => x.HeadwordItems)
.TransformUsing(Transformers.DistinctRootEntity)
.SingleOrDefault();
return(result);
}
public virtual Project GetProjectByExternalId(string externalId, ProjectTypeEnum projectType)
{
return(GetSession().QueryOver <Project>()
.Where(x => x.ExternalId == externalId && x.ProjectType == projectType && x.IsRemoved == false)
.SingleOrDefault());
}
public IFulltextStorage GetFulltextStorage(ProjectTypeEnum projectType)
{
var storageType = GetStorageType(projectType);
return(m_fulltextStorages[storageType]);
}
public virtual IList <MetadataResource> GetMetadataWithFetchForBiblModuleByProjectExternalIds(IEnumerable <string> projectExternalIdList, ProjectTypeEnum projectType)
{
Resource resourceAlias = null;
Project projectAlias = null;
var session = GetSession();
var result = session.QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.WhereRestrictionOn(() => projectAlias.ExternalId).IsInG(projectExternalIdList)
.And(() => projectAlias.ProjectType == projectType)
.And(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectAlias.IsRemoved == false)
.Fetch(SelectMode.Fetch, x => x.Resource)
.Fetch(SelectMode.Fetch, x => x.Resource.Project)
.Fetch(SelectMode.Fetch, x => x.Resource.Project.LatestPublishedSnapshot)
.Fetch(SelectMode.Fetch, x => x.Resource.Project.LatestPublishedSnapshot.DefaultBookType)
.List();
return(result);
}
/// <summary>
/// 设置当前语言
/// </summary>
/// <param name="project">项目</param>
/// <param name="lang">语言</param>
internal static void SetLang(ProjectTypeEnum project, LangTypeEnum lang)
{
var key = string.Format("{0}-{1}", project.ToString().ToUpper(), "LANG");
_lanJsonResourceCache.Set <LangTypeEnum>(key, lang);
}
public List <CorpusSearchResultContract> GetCorpusSearchResultByExternalIds(List <CorpusSearchResultData> list, ProjectTypeEnum projectType)
{
var projectExternalIds = list.Select(x => x.ProjectExternalId);
var dbProjects = m_metadataRepository.InvokeUnitOfWork(x => x.GetMetadataByProjectExternalIds(projectExternalIds, projectType));
var bookDictionary = dbProjects.ToDictionary(x => x.Resource.Project.ExternalId);
// Load all pages in one transaction
var orderedPageResourceList = m_bookRepository.InvokeUnitOfWork(repository =>
{
var result = new List <PageResource>();
foreach (var corpusSearchResultData in list)
{
var page = repository.GetPagesByTextExternalId(new [] { corpusSearchResultData.PageResultContext.TextExternalId }, corpusSearchResultData.ProjectExternalId, projectType);
result.Add(page.First());
}
return(result);
});
// Process results
var orderedResultList = new List <CorpusSearchResultContract>();
for (int i = 0; i < list.Count; i++)
{
var corpusResultData = list[i];
var pageInfo = orderedPageResourceList[i];
var projectMetadata = bookDictionary[corpusResultData.ProjectExternalId];
var pageContextContract = m_mapper.Map <PageWithContextContract>(pageInfo);
pageContextContract.ContextStructure = corpusResultData.PageResultContext.ContextStructure;
var corpusItemContract = new CorpusSearchResultContract
{
PageResultContext = pageContextContract,
Author = projectMetadata.AuthorsLabel,
BookId = projectMetadata.Resource.Project.Id,
OriginDate = projectMetadata.OriginDate,
RelicAbbreviation = projectMetadata.RelicAbbreviation,
SourceAbbreviation = projectMetadata.SourceAbbreviation,
Title = projectMetadata.Title,
Notes = corpusResultData.Notes,
BibleVerseResultContext = corpusResultData.BibleVerseResultContext,
VerseResultContext = corpusResultData.VerseResultContext,
};
orderedResultList.Add(corpusItemContract);
}
return(orderedResultList);
}
public async Task <HttpResponseMessage> SaveRequestQuote()
{
try
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = HttpContext.Current.Server.MapPath("~/RequestQuoteAttachment");
Directory.CreateDirectory(root);
var provider = new MultipartFormDataStreamProvider(root);
var result = await Request.Content.ReadAsMultipartAsync(provider);
var contactId = result.FormData["RequestQuoteId"];
if (contactId == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
RequestQuoteEntity objRequestQuoteEntity = new RequestQuoteEntity();
objRequestQuoteEntity.RequestQuoteId = Convert.ToInt32(result.FormData["RequestQuoteId"].ToString());
objRequestQuoteEntity.FullName = result.FormData["FullName"].ToString();
objRequestQuoteEntity.PhoneNumber = result.FormData["PhoneNumber"].ToString();
objRequestQuoteEntity.EmailAddress = result.FormData["EmailAddress"].ToString();
objRequestQuoteEntity.City = result.FormData["City"].ToString();
objRequestQuoteEntity.Company = result.FormData["Company"].ToString();
objRequestQuoteEntity.ProjectTypeId = Convert.ToInt32(result.FormData["ProjectTypeId"]);
objRequestQuoteEntity.BudgetId = Convert.ToInt32(result.FormData["BudgetId"]);
objRequestQuoteEntity.ProjectDescription = result.FormData["ProjectDescription"].ToString();
var requestQuoteId = _unitOfWork.SQLStringReturn("EXEC SaveRequestQuotes @FullName,@PhoneNumber,@EmailAddress," +
"@City,@Company,@ProjectTypeId,@BudgetId,@ProjectDescription", new SqlParameter[]
{
new SqlParameter("@FullName", objRequestQuoteEntity.FullName),
new SqlParameter("@PhoneNumber", objRequestQuoteEntity.PhoneNumber),
new SqlParameter("@EmailAddress", objRequestQuoteEntity.EmailAddress),
new SqlParameter("@City", objRequestQuoteEntity.City),
new SqlParameter("@Company", objRequestQuoteEntity.Company),
new SqlParameter("@ProjectTypeId", objRequestQuoteEntity.ProjectTypeId),
new SqlParameter("@BudgetId", objRequestQuoteEntity.BudgetId),
new SqlParameter("@ProjectDescription", objRequestQuoteEntity.ProjectDescription)
});
if (Convert.ToInt32(requestQuoteId) > 0)
{
HttpFileCollection uploadedFiles = HttpContext.Current.Request.Files;
for (int i = 0; i < uploadedFiles.Count; i++)
{
HttpPostedFile file = uploadedFiles[i];
if (file.ContentLength > 0)
{
string fileExtension = Path.GetExtension(file.FileName);
string fileName = objRequestQuoteEntity.FullName.Replace(" ", "_") + Guid.NewGuid() + fileExtension;
file.SaveAs(root + "\\" + fileName);
var attachmentId = _unitOfWork.SQLStringReturn("EXEC SaveRequestQuoteAttchments @RequestQuoteId,@Path", new SqlParameter[]
{
new SqlParameter("@RequestQuoteId", requestQuoteId),
new SqlParameter("@Path", fileName)
});
}
}
ProjectTypeEnum prjtype = (ProjectTypeEnum)Enum.Parse(typeof(ProjectTypeEnum), Convert.ToString(objRequestQuoteEntity.ProjectTypeId));
BudgetEnum budgettype = (BudgetEnum)Enum.Parse(typeof(BudgetEnum), Convert.ToString(objRequestQuoteEntity.BudgetId));
string AdminMail = System.Configuration.ConfigurationManager.AppSettings["ContactUsEmailId"];
string bodyAdminTemplate = System.IO.File.ReadAllText(System.Web.Hosting.HostingEnvironment.MapPath("~/EmailTemplate/AdminRequestQuote.html"));
bodyAdminTemplate = bodyAdminTemplate.Replace("[@FullName]", objRequestQuoteEntity.FullName);
bodyAdminTemplate = bodyAdminTemplate.Replace("[@Email]", objRequestQuoteEntity.EmailAddress);
bodyAdminTemplate = bodyAdminTemplate.Replace("[@Mobile]", objRequestQuoteEntity.PhoneNumber);
bodyAdminTemplate = bodyAdminTemplate.Replace("[@company]", objRequestQuoteEntity.Company);
bodyAdminTemplate = bodyAdminTemplate.Replace("[@ProjectType]", EnumDescription.ToDescription(prjtype));
bodyAdminTemplate = bodyAdminTemplate.Replace("[@Budget]", EnumDescription.ToDescription(budgettype));
bodyAdminTemplate = bodyAdminTemplate.Replace("[@ProjectDescription]", objRequestQuoteEntity.ProjectDescription);
Task Admintask = new Task(() => Email.Send(AdminMail, bodyAdminTemplate, "Request Enquiry from " + objRequestQuoteEntity.FullName, "", null));
Admintask.Start();
}
return(Request.CreateResponse(HttpStatusCode.OK, "success!"));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Error!"));
}
}
/// <summary>
/// 设置语言资源缓存
/// </summary>
/// <param name="project">项目</param>
/// <param name="jsonResource">语言资源</param>
internal static void SetJsonResource(ProjectTypeEnum project,
Dictionary <LangTypeEnum, Dictionary <string, string> > jsonResource)
{
_lanJsonResourceCache.Set(project, jsonResource);
}
public SearchHeadwordRowNumberWork(BookViewRepository bookRepository, CategoryRepository categoryRepository,
HeadwordRowNumberSearchRequestContract request, int userId, ProjectTypeEnum projectType, IMapper mapper) : base(bookRepository)
{
m_bookRepository = bookRepository;
m_categoryRepository = categoryRepository;
m_request = request;
m_userId = userId;
m_projectType = projectType;
m_mapper = mapper;
}
/// <summary>
/// 设置当前项目的语言类型
/// </summary>
/// <param name="project">项目</param>
/// <param name="lang">语言</param>
public static void SetLang(ProjectTypeEnum project, LangTypeEnum lang)
{
LanguageCachedHelper.SetLang(project, lang);
}
public virtual IList <MetadataResource> GetMetadataByProjectExternalIds(IEnumerable <string> projectExternalIds, ProjectTypeEnum projectType)
{
Resource resourceAlias = null;
Project projectAlias = null;
return(GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.WhereRestrictionOn(() => projectAlias.ExternalId).IsInG(projectExternalIds)
.And(() => projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false)
.And(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved)
.List());
}
public virtual IList <PageResource> GetPagesByTextExternalId(IEnumerable <string> textExternalIds, string projectExternalId, ProjectTypeEnum projectType)
{
return(GetPagesByTextExternalIdInner(textExternalIds, null, projectExternalId, projectType));
}
public List <HeadwordContract> GetHeadwordSearchResultByExternalIds(List <HeadwordDictionaryEntryData> list, ProjectTypeEnum projectType)
{
var orderedResultList = new List <HeadwordContract>();
foreach (var headwordDictionaryEntryData in list)
{
var headwordInfo = m_resourceRepository.InvokeUnitOfWork(x => x.GetHeadwordWithFetchByExternalId(headwordDictionaryEntryData.ProjectExternalId, headwordDictionaryEntryData.HeadwordExternalId, projectType));
var headwordContract = m_mapper.Map <HeadwordContract>(headwordInfo);
orderedResultList.Add(headwordContract);
}
return(orderedResultList);
}
public virtual IList <FullProjectImportLog> GetAllImportLogByExternalId(string projectExternalId, ProjectTypeEnum projectType)
{
Project projectAlias = null;
return(GetSession().QueryOver <FullProjectImportLog>()
.JoinAlias(x => x.Project, () => projectAlias)
.Where(x => projectAlias.ExternalId == projectExternalId && projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false)
.List());
}
/// <summary>
/// 获取本地语言显示信息
/// </summary>
/// <param name="project">项目</param>
/// <param name="key">显示项</param>
/// <returns></returns>
internal static string GetMessage(ProjectTypeEnum project, string key)
{
var message = GetItem(project, key);
return(message);
}
public virtual IList <MetadataResource> GetMetadataByBookTypeWithCategories(BookTypeEnum bookTypeEnum, int userId, ProjectTypeEnum projectType,
int start, int count)
{
Resource resourceAlias = null;
Snapshot snapshotAlias = null;
BookType bookTypeAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var resultList = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved)
.WithSubquery.WhereProperty(() => resourceAlias.Project.Id).In(QueryOver.Of <Project>()
.Where(x => x.ProjectType == projectType && x.IsRemoved == false)
.JoinAlias(x => x.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookTypeEnum)
.JoinAlias(x => x.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(() => userAlias.Id == userId)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.Select(x => x.Id))
.OrderBy(x => x.Title).Asc
.Skip(start)
.Take(count)
.List();
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(resultList.Select(x => x.Resource.Project.Id))
.Fetch(SelectMode.Fetch, x => x.Categories)
.List();
return(resultList);
}
/// <summary>
/// 获取本地语言显示信息
/// </summary>
/// <param name="project">项目</param>
/// <param name="key">显示项</param>
/// <param name="message">附属消息</param>
/// <returns></returns>
internal static string GetMessage(ProjectTypeEnum project, string key, string message)
{
var fullMessage = string.Format("{0}:{1}", GetItem(project, key), message);
return(fullMessage);
}
/// <summary>
/// 获取语言资源
/// </summary>
/// <param name="project">项目</param>
/// <returns>语言资源</returns>
internal static Dictionary <LangTypeEnum, Dictionary <string, string> > GetJsonResource(ProjectTypeEnum project)
{
Dictionary <LangTypeEnum, Dictionary <string, string> > resources = null;
_lanJsonResourceCache.TryGetValue(project, out resources);
return(resources);
}
public virtual MetadataResource GetLatestMetadataResourceByExternalId(string projectExternalId, ProjectTypeEnum projectType)
{
Resource resourceAlias = null;
Project projectAlias = null;
var query = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.Where(x => projectAlias.ExternalId == projectExternalId && projectAlias.ProjectType == projectType &&
resourceAlias.ResourceType == ResourceTypeEnum.ProjectMetadata && resourceAlias.LatestVersion.Id == x.Id &&
!resourceAlias.IsRemoved && projectAlias.IsRemoved == false)
.Fetch(SelectMode.Fetch, x => x.Resource);
return(query.SingleOrDefault());
}
/// <summary>
/// 获取当前语言
/// </summary>
/// <param name="project">项目</param>
/// <returns>语言</returns>
internal static LangTypeEnum GetLang(ProjectTypeEnum project)
{
var key = string.Format("{0}-{1}", project.ToString().ToUpper(), "LANG");
return(_lanJsonResourceCache.Get <LangTypeEnum>(key));
}
public static string SelectProjectType(ProjectTypeEnum input)
{
//Dictionary to link String to AccessPermission
//Dictionary to link String to AccessPermission
Dictionary <string, ProjectTypeEnum> projectTypeDict =
new Dictionary <string, ProjectTypeEnum>();
projectTypeDict.Add("Commercial", ProjectTypeEnum.Commercial);
projectTypeDict.Add("Convention Center", ProjectTypeEnum.ConventionCenter);
projectTypeDict.Add("Data Center", ProjectTypeEnum.DataCenter);
projectTypeDict.Add("Hotel / Motel", ProjectTypeEnum.HotelMotel);
projectTypeDict.Add("Office", ProjectTypeEnum.Office);
projectTypeDict.Add("Parking Structure / Garage", ProjectTypeEnum.ParkingStructureGarage);
projectTypeDict.Add("Performing Arts", ProjectTypeEnum.PerformingArts);
projectTypeDict.Add("Retail", ProjectTypeEnum.Retail);
projectTypeDict.Add("Stadium/Arena", ProjectTypeEnum.StadiumArena);
projectTypeDict.Add("Theme Park", ProjectTypeEnum.ThemePark);
projectTypeDict.Add("Warehouse", ProjectTypeEnum.Warehouse);
projectTypeDict.Add("Healthcare", ProjectTypeEnum.Healthcare);
projectTypeDict.Add("Assisted Living / Nursing Home", ProjectTypeEnum.AssistedLivingNursingHome);
projectTypeDict.Add("Hospital", ProjectTypeEnum.Hospital);
projectTypeDict.Add("Medical Laboratory", ProjectTypeEnum.MedicalLaboratory);
projectTypeDict.Add("Medical Office", ProjectTypeEnum.MedicalOffice);
projectTypeDict.Add("OutPatient Surgery Center", ProjectTypeEnum.OutPatientSurgeryCenter);
projectTypeDict.Add("Institutional", ProjectTypeEnum.Institutional);
projectTypeDict.Add("Court House", ProjectTypeEnum.CourtHouse);
projectTypeDict.Add("Dormitory", ProjectTypeEnum.Dormitory);
projectTypeDict.Add("Education Facility", ProjectTypeEnum.EducationFacility);
projectTypeDict.Add("Government Building", ProjectTypeEnum.GovernmentBuilding);
projectTypeDict.Add("Library", ProjectTypeEnum.Library);
projectTypeDict.Add("Military Facility", ProjectTypeEnum.MilitaryFacility);
projectTypeDict.Add("Museum", ProjectTypeEnum.Museum);
projectTypeDict.Add("Prison / Correctional Facility", ProjectTypeEnum.PrisonCorrectionalFacility);
projectTypeDict.Add("Recreation Building", ProjectTypeEnum.RecreationBuilding);
projectTypeDict.Add("Religious Building", ProjectTypeEnum.ReligiousBuilding);
projectTypeDict.Add("Research Facility / Laboratory", ProjectTypeEnum.ResearchFacilityLaboratory);
projectTypeDict.Add("Residential", ProjectTypeEnum.Residential);
projectTypeDict.Add("Multi-Family Housing", ProjectTypeEnum.MultiFamilyHousing);
projectTypeDict.Add("Single-Family Housing", ProjectTypeEnum.SingleFamilyHousing);
projectTypeDict.Add("Infrastructure", ProjectTypeEnum.Infrastructure);
projectTypeDict.Add("Airport", ProjectTypeEnum.Airport);
projectTypeDict.Add("Bridge", ProjectTypeEnum.Bridge);
projectTypeDict.Add("Canal / Waterway", ProjectTypeEnum.CanalWaterway);
projectTypeDict.Add("Dams / Flood Control / Reservoirs", ProjectTypeEnum.DamsFloodControlReservoirs);
projectTypeDict.Add("Harbor / River Development", ProjectTypeEnum.HarborRiverDevelopment);
projectTypeDict.Add("Rail", ProjectTypeEnum.Rail);
projectTypeDict.Add("Seaport", ProjectTypeEnum.Seaport);
projectTypeDict.Add("Streets / Roads / Highways", ProjectTypeEnum.StreetsRoadsHighways);
projectTypeDict.Add("Transportation Building", ProjectTypeEnum.TransportationBuilding);
projectTypeDict.Add("Tunnel", ProjectTypeEnum.Tunnel);
projectTypeDict.Add("Waste Water / Sewers", ProjectTypeEnum.WasteWaterSewers);
projectTypeDict.Add("Water Supply", ProjectTypeEnum.WaterSupply);
projectTypeDict.Add("Industrial & Energy", ProjectTypeEnum.IndustrialEnergy);
projectTypeDict.Add("Manufacturing / Factory", ProjectTypeEnum.ManufacturingFactory);
projectTypeDict.Add("Oil & Gas", ProjectTypeEnum.OilGas);
projectTypeDict.Add("Plant", ProjectTypeEnum.Plant);
projectTypeDict.Add("Power Plant", ProjectTypeEnum.PowerPlant);
projectTypeDict.Add("Solar Far", ProjectTypeEnum.SolarFar);
projectTypeDict.Add("Utilities", ProjectTypeEnum.Utilities);
projectTypeDict.Add("Wind Farm", ProjectTypeEnum.WindFarm);
projectTypeDict.Add("Sample Projects", ProjectTypeEnum.SampleProjects);
projectTypeDict.Add("Demonstration Project", ProjectTypeEnum.DemonstrationProject);
projectTypeDict.Add("Template Project", ProjectTypeEnum.TemplateProject);
projectTypeDict.Add("Training Project", ProjectTypeEnum.TrainingProject);
//reverse Dict
var projectTypeDict_reverse = new Dictionary <ProjectTypeEnum, string>();
foreach (var entry in projectTypeDict)
{
if (!projectTypeDict_reverse.ContainsKey(entry.Value))
{
projectTypeDict_reverse.Add(entry.Value, entry.Key);
}
}
return(projectTypeDict_reverse[input]);
}
