public Project(
            int projectId,
            string name,
            ProjectType[] projectType,
            string info,
            ProjectStatus projectStatus,
            Common.Image landingImage,
            Uri versionControlSystemUri,
            Uri projectManagementSystemUri,
            HashSet<Issue> issues,
            HashSet<ProjectMembership> projectMemberships,
            HashSet<Common.Image> screenshots)
        {
            Require.Positive(projectId, nameof(projectId));
            Require.NotEmpty(name, nameof(name));
            Require.NotNull(info, nameof(info));
            Require.NotNull(versionControlSystemUri, nameof(versionControlSystemUri));
            Require.NotNull(projectManagementSystemUri, nameof(projectManagementSystemUri));

            ProjectId = projectId;
            Name = name;
            ProjectType = projectType;
            Info = info;
            ProjectStatus = projectStatus;
            LandingImage = landingImage;
            VersionControlSystemUri = versionControlSystemUri;
            ProjectManagementSystemUri = projectManagementSystemUri;
            Issues = issues;
            ProjectMemberships = projectMemberships;
            Screenshots = screenshots;
        }

 public OvlModelSearchResult(ProjectType type, int modelsFound, int totalModels, List<string> remainingOvlModels)
 {
     _type = type;
     _modelsFound = modelsFound;
     _totalModels = totalModels;
     _remainingOvlModels = remainingOvlModels;
 }

        public Order(
            string header,
            string customerName, 
            DateTime createdOnDateTime,
            DateTime deadLine, 
            MailAddress email, 
            string description,
            ISet<Uri> attachments, 
            ProjectType projectType)
        {
            Require.NotEmpty(header, nameof(header));
            Require.NotEmpty(customerName, nameof(customerName));
            Require.NotNull(email, nameof(email));
            Require.NotNull(description, nameof(description));
            Require.NotNull(attachments, nameof(attachments));

            Header = header;
            CustomerName = customerName;
            CreatedOnDateTime = createdOnDateTime;
            DeadLine = deadLine;
            Email = email;
            Description = description;
            Attachments = attachments;
            ProjectType = projectType;
        }

        public static string CreateProjectFile(BootstrappedProject project, ProjectType projectType, IEnumerable<ProjectReferenceData> references = null, bool isSelfHost = false)
        {
            var includes = CrawlFoldersForIncludes(project.ProjectRoot);
            var compileIncludesText = string.Join("", includes.Compile.ToArray());

            var contentIncludesText = "";
            var referencesText = "";

            var selfHostReferences = isSelfHost ? Environment.NewLine + @"    <Reference Include=""System.ServiceProcess"" />" : "";
            var queueConfigurationReferences = isSelfHost ? Environment.NewLine + @"    <Reference Include=""System.Configuration"" />" : "";

            if (references != null)
            {
                var projectReferences = references.Select(CreateProjectReference);
                referencesText = Environment.NewLine + "<ItemGroup>" + string.Join("", projectReferences.ToArray()) + Environment.NewLine + "</ItemGroup>";
            }

            if (includes.Content.Any())
            {
                contentIncludesText = Environment.NewLine + "<ItemGroup>" + string.Join("", includes.Content.ToArray()) + Environment.NewLine + "</ItemGroup>";
            }

            var projectFileContent =
                ClassLibraryProject
                    .Replace("{{projectGuid}}", project.ProjectGuid.ToString())
                    .Replace("{{outputType}}", projectType.ToString())
                    .Replace("{{assemblyName}}", project.ProjectName)
                    .Replace("{{compileIncludes}}", compileIncludesText)
                    .Replace("{{contentIncludes}}", contentIncludesText)
                    .Replace("{{queueConfigurationReferences}}", queueConfigurationReferences)
                    .Replace("{{selfHostReferences}}", selfHostReferences)
                    .Replace("{{referenceIncludes}}", referencesText);

            return projectFileContent;
        }

        internal static void generate(string filename, string version, string asmName, string ns, ProjectType type)
        {
            Project p = new Project();
            string typeDesc = null;

            p.Xml.DefaultTargets = "Build";
            createItemGroup(p, "ProjectConfigurations");
            createGlobals(ns, type, p, "Globals");
            p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.Default.props");

            switch (type) {
                case ProjectType.ConsoleApp: typeDesc = "Application"; break;
                case ProjectType.XamlApp: typeDesc = "Application"; break;
                case ProjectType.ClassLibrary: typeDesc = "DynamicLibrary"; break;
                default:
                    throw new InvalidOperationException("unhandled projectType: " + type);
            }
            createCfgProp(p.Xml, typeDesc, true);
            createCfgProp(p.Xml, typeDesc, false);
            p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.props");
            addPropertySheetImports(p.Xml);
            addPropertyGroup(p.Xml, makeCfgCondition(DEBUG, PLATFORM), new Blah2(b2));
            addPropertyGroup(p.Xml, makeCfgCondition(RELEASE, PLATFORM), new Blah2(b2));
            addItemDefs(p.Xml);

            const string C_TARGET_RULES = @"$(VCTargetsPath)\Microsoft.Cpp.targets";
            var v99 = p.Xml.CreateImportElement(C_TARGET_RULES);
            p.Xml.AppendChild(v99);
            p.Save(filename);
        }

 public ProjectInfo( ProjectType pt )
 {
     _po = new Options();
     _strName = null;
     _rc = new RunCollection( this );
     _pt = pt;
 }

        public AdminProject(
            int projectId,
            string name,
            ProjectType[] projectType,
            string info,
            ProjectStatus projectStatus,
            Common.Image landingImage,
            AccessLevel accessLevel,
            Uri versionControlSystemUri,
            Uri projectManagementSystemUri,
            HashSet<Issue> issues,
            HashSet<ProjectMembership> projectDevelopers,
            HashSet<Common.Image> screenshots)
        {
            Require.Positive(projectId, nameof(projectId));
            Require.NotEmpty(name, nameof(name));
            Require.NotNull(info, nameof(info));
            Require.NotNull(versionControlSystemUri, nameof(versionControlSystemUri));
            Require.NotNull(projectManagementSystemUri, nameof(projectManagementSystemUri));

            ProjectId = projectId;
            Name = name;
            ProjectType = projectType ?? new[] {Common.ProjectType.Other};
            AccessLevel = accessLevel;
            Info = info;
            ProjectStatus = projectStatus;
            LandingImage = landingImage;
            VersionControlSystemUri = versionControlSystemUri;
            ProjectManagementSystemUri = projectManagementSystemUri;
            Issues = issues ?? new HashSet<Issue>();
            ProjectMemberships = projectDevelopers ?? new HashSet<ProjectMembership>();
            Screenshots = screenshots ?? new HashSet<Common.Image>();
        }

        public MainWindow(IGUIToolkit guiToolkit)
            : base("LongoMatch")
        {
            this.Build();

            this.guiToolKit = guiToolkit;

            projectType = ProjectType.None;

            timeline = new TimeLineWidget();
            downbox.PackStart(timeline, true, true, 0);

            guTimeline = new GameUnitsTimelineWidget ();
            downbox.PackStart(guTimeline, true, true, 0);

            player.SetLogo(System.IO.Path.Combine(Config.ImagesDir(),"background.png"));
            player.LogoMode = true;
            player.Tick += OnTick;
            player.Detach += (sender, e) => DetachPlayer(true);

            capturer.Visible = false;
            capturer.Logo = System.IO.Path.Combine(Config.ImagesDir(),"background.png");
            capturer.CaptureFinished += (sender, e) => {CloseCaptureProject();};

            buttonswidget.Mode = TagMode.Predifined;
            localPlayersList.Team = Team.LOCAL;
            visitorPlayersList.Team = Team.VISITOR;

            ConnectSignals();
            ConnectMenuSignals();

            if (!Config.useGameUnits)
                GameUnitsViewAction.Visible = false;
        }

    public string GetAssemblyInfoText(VersionVariables vars, string rootNamespace, ProjectType projectType)
    {
        string assemblyInfoFormat;
        if (projectType == ProjectType.CSharp)
        {
            assemblyInfoFormat = csharpAssemblyInfoFormat;
        }
        else if (projectType == ProjectType.FSharp)
        {
            assemblyInfoFormat = fsharpAssemblyInfoFormat;
        }
        else
        {
            throw new ArgumentException("ProjectType");
        }

        var v = vars.ToList();

        var assemblyInfo = string.Format(
        assemblyInfoFormat,
        vars.AssemblySemVer,
        vars.MajorMinorPatch + ".0",
        vars.InformationalVersion,
        GenerateStaticVariableMembers(v, projectType),
        rootNamespace);

        return assemblyInfo;
    }

 public ProjectUploadingEventArg(DomainActionData actionData, string projectId, string projectName, ProjectType projectType, ProjectSubtype projectSubtype)
     : base(actionData)
 {
     ProjectId = projectId;
     ProjectName = projectName;
     ProjectType = projectType;
     ProjectSubtype = projectSubtype;
 }

 public Project(ProjectType type, string name, Guid id, ProjectUser founder)
 {
     Type = type;
     Name = name;
     DateCreated = System.DateTime.Now;
     Id = id;
     Users = new Dictionary<Guid, ProjectUser>();
     //Users[founder.Id] = founder;
 }

 public ModisSourceProduct(string name, string baseUrl, SatelliteType sateType, 
                             ProductType prodType, ProjectType projType, int days)
 {
     productName = name;
     baseFtpUrl = baseUrl;
     satellite = sateType;
     productType = prodType;
     projectType = projType;
     observeInterval = days;
 }

        public Task AddProjectUploading(DomainActionData actionData, string projectId, string projectName, ProjectType projectType, ProjectSubtype projectSubtype)
        {
            string eventId = GuidWraper.Generate();
            DateTime curDateTime = DateTimeWrapper.CurrentDateTime();

            StatProjectUploadingV2Entity projectUploadingEntity = StatEntityFactory.CreateProjectUploadingEntity(eventId, curDateTime, actionData, projectId, projectName, projectType, projectSubtype);
            ITableRepository<StatProjectUploadingV2Entity> projectUploadingRepository = RepositoryFactory.Create<StatProjectUploadingV2Entity>();

            return projectUploadingRepository.AddAsync(projectUploadingEntity);
        }

        /// <summary>
        /// Gets the actual or target cost entry for the given project type and the month.
        /// </summary>
        /// <param name="projectType">Type of project.</param>
        /// <param name="costType">The actual or target cost indicator.</param>
        /// <param name="month">Month for the calculation.</param>
        /// <returns>The cost value.</returns>
        public long GetCostEntry(ProjectType projectType, CostType costType, int month)
        {
            var key = ProjectCostEntry.ToString(projectType, costType, month);
            if (this.costEntries.ContainsKey(key))
            {
                return this.costEntries[key].Cost;
            }

            return 0;
        }

        public ActionResult Create(ProjectType projecttype)
        {
            if (ModelState.IsValid)
            {
                db.ProjectTypes.Add(projecttype);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            return View(projecttype);
        }

		public VSProject CreateVSProjectFromFromFolder(string name, string folder, ProjectType type)
		{
			XmlDocument doc = new XmlDocument(new NameTable());

			XmlNamespaceManager nsManager = new XmlNamespaceManager(doc.NameTable);
			nsManager.AddNamespace("", "http://schemas.microsoft.com/developer/msbuild/2003");
			nsManager.PushScope();

			doc.Load(Path.Combine(context.TemplateFolder.FullName, "VS/CSProject_template.xml"));

			return VSProject.Create(name, folder, type, doc);
		}

        public ActionResult Create(ProjectType ptype)
        {
            if (ModelState.IsValid)
            {
                ptype.Date_Creation = DateTime.Now;

                context.ProjectTypes.Add(ptype);
                context.SaveChanges();
                return RedirectToAction("Index");
            }

            return View(ptype);
        }

        protected async Task<HttpResponseMessage> PostPackage(ProjectType projectType, ReleaseType releaseType,
            string versionString)
        {
            string unescapedVersionString = versionString.Replace("-", ".");
            Version version;
            if (!Version.TryParse(unescapedVersionString, out version))
            {
                return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType,
                    "versionString is not valid: " + versionString);
            }
            if (!Request.Content.IsMimeMultipartContent())
            {
                return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, 
                    "Content must be mime multipart");
            }

            try
            {
                var name = string.Format("{0}_{1}_{2}.zip",
                    projectType,
                    releaseType,
                    unescapedVersionString);

                Guid fileId;
                using (var contentStream = await Request.Content.ReadAsStreamAsync())
                {
                    fileId = Files.Create(name, contentStream);
                }

                var newFile = Context.Files.Single(file => file.FileId == fileId);

                var package = new WurmAssistantPackage()
                {
                    ProjectType = projectType,
                    ReleaseType = releaseType,
                    VersionString = unescapedVersionString,
                    File = newFile
                };
                Context.WurmAssistantPackages.Add(package);

                RemoveOutdatedPackages(projectType, releaseType);
                Context.SaveChanges();

                return Request.CreateResponse(HttpStatusCode.OK);
            }
            catch (System.Exception e)
            {
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
            }
        }

 private string GetOutputType(ProjectType type)
 {
     switch (type)
     {
         case ProjectType.Executable:
             return "Exe";
         case ProjectType.WindowsExecutable:
             return "WinExe";
         case ProjectType.Library:
             return "Library";
         default:
             throw new ArgumentOutOfRangeException("type");
     }
 }

 internal static string ToSerializableString(ProjectType type)
 {
     switch (type)
     {
         case ProjectType.StandardExe:
             return "Exe";
         case ProjectType.ActiveXExe:
             return "OleExe";
         case ProjectType.ActiveXDll:
             return "OleDll";
         case ProjectType.ActiveXControl:
             return "Control";
         default:
             throw new ArgumentException("type");
     }
 }