public HttpResponseMessage UpdateSoftwareRelease(SoftwareReleaseDefinition softwareReleaseDefinition)
        {
            HttpResponseMessage response = Request.CreateResponse();

            Release release = _dbEntities.Releases.Where(a => a.ReleaseID == softwareReleaseDefinition.SoftwareReleaseID).FirstOrDefault();

            if (release != null)
            {
                release.ReleaseCode                 = softwareReleaseDefinition.SoftwareReleaseCode;
                release.ModelYear                   = softwareReleaseDefinition.ASystemModelYear;
                release.VersionNumber               = softwareReleaseDefinition.SoftwareVersionNumber;
                release.ReleaseTypeID               = Convert.ToInt32(softwareReleaseDefinition.SoftwareReleaseTypeName);
                release.ConnectCapableIndicator     = softwareReleaseDefinition.POCCapable;
                release.MinimumConnectClientVersion = softwareReleaseDefinition.MinimumPOCClientNumber;
                release.LastModifiedUserName        = softwareReleaseDefinition.LastModifiedUserName;
                release.CreatedDateTime             = softwareReleaseDefinition.CreationDateTime;
                release.LastModifiedDateTime        = softwareReleaseDefinition.LastModifiedDateTime;
                release.ActiveIndicator             = softwareReleaseDefinition.IsActive;
                _dbEntities.SaveChanges();
            }
            try
            {
                return(Request.CreateResponse(HttpStatusCode.OK, release.ReleaseID));
            }
            catch (Exception ex)
            {
                response.Content    = new StringContent("[]");
                response.StatusCode = HttpStatusCode.InternalServerError;
            }
            return(response);
        }
        public HttpResponseMessage AddSoftwareReleaseComponents(SoftwareReleaseDefinition softwareReleaseDefinition)
        {
            HttpResponseMessage response = Request.CreateResponse();

            try
            {
                int     nextReleaseID = _dbEntities.Releases.Max(m => m.ReleaseID);
                Release release       = new Release()
                {
                    ReleaseID                   = nextReleaseID + 1,
                    SystemGroupCode             = softwareReleaseDefinition.ASystemGroupCode,
                    ReleaseCode                 = softwareReleaseDefinition.SoftwareReleaseCode,
                    ModelYear                   = softwareReleaseDefinition.ASystemModelYear,
                    VersionNumber               = softwareReleaseDefinition.SoftwareVersionNumber,
                    ReleaseTypeID               = Convert.ToInt32(softwareReleaseDefinition.SoftwareReleaseTypeName),
                    ConnectCapableIndicator     = softwareReleaseDefinition.POCCapable,
                    MinimumConnectClientVersion = softwareReleaseDefinition.MinimumPOCClientNumber,
                    LastModifiedUserName        = softwareReleaseDefinition.LastModifiedUserName,
                    CreatedDateTime             = softwareReleaseDefinition.CreationDateTime,
                    LastModifiedDateTime        = softwareReleaseDefinition.LastModifiedDateTime,
                    ActiveIndicator             = softwareReleaseDefinition.IsActive
                };
                _dbEntities.Releases.Add(release);
                _dbEntities.SaveChanges();

                return(Request.CreateResponse(HttpStatusCode.OK, release.ReleaseID));
            }
            catch (Exception ex)
            {
                response.Content    = new StringContent("[]");
                response.StatusCode = HttpStatusCode.InternalServerError;
            }
            return(response);
        }
        public HttpResponseMessage GetSoftwareReleaseDefinitionsBySoftwareReleaseID(int SoftwareReleaseID, string UserName)
        {
            HttpResponseMessage       response = Request.CreateResponse();
            SoftwareReleaseDefinition softwareReleaseDefinition = new SoftwareReleaseDefinition();

            //IEnumerable<KeyValuePair<string, string>> queryStringData = Request.GetQueryNameValuePairs();
            try
            {
                softwareReleaseDefinition = (from r in _dbEntities.Releases
                                             where r.ReleaseID == SoftwareReleaseID
                                             select new
                {
                    SoftwareReleaseID = r.ReleaseID,
                    ASystemModelYear = r.ModelYear,
                    ASystemGroupCode = r.SystemGroupCode,
                    SoftwareReleaseCode = r.ReleaseCode,
                    SoftwareVersionNumber = r.VersionNumber,
                    MinimumPOCClientNumber = r.MinimumConnectClientVersion,
                    ReleaseTypeId = r.ReleaseTypeID,
                    POCCapable = r.ConnectCapableIndicator,
                    IsActive = r.ActiveIndicator,
                }).AsEnumerable().Select(s => new SoftwareReleaseDefinition
                {
                    SoftwareReleaseID       = s.SoftwareReleaseID,
                    ASystemModelYear        = s.ASystemModelYear,
                    ASystemGroupCode        = s.ASystemGroupCode,
                    SoftwareReleaseCode     = s.SoftwareReleaseCode,
                    SoftwareVersionNumber   = s.SoftwareVersionNumber,
                    MinimumPOCClientNumber  = s.MinimumPOCClientNumber,
                    SoftwareReleaseTypeName = Convert.ToString(s.ReleaseTypeId),
                    POCCapable = s.POCCapable,
                    IsActive   = s.IsActive,
                }).FirstOrDefault();

                var releaseNote = (from rn in _dbEntities.ReleaseNotes
                                   join dt in _dbEntities.DialectTexts on rn.ReleaseNoteTextID equals dt.TextID
                                   where rn.ReleaseID == softwareReleaseDefinition.SoftwareReleaseID &&
                                   rn.ReleaseNoteTypeCode == "CUST" && dt.MicrosoftLocaleID == 1033
                                   select new
                {
                    ReleaseNoteTypeCode = rn.ReleaseNoteTypeCode,
                    MicroSoftLocaleID = dt.MicrosoftLocaleID,
                    RCReleaseNote = dt.LanguageText,
                    ReleaseNoteTextId = rn.ReleaseNoteTextID
                }).AsEnumerable().Select(s => new SoftwareReleaseDefinition()
                {
                    SoftwareReleaseNoteTypeCode = s.ReleaseNoteTypeCode,
                    SoftwareReleaseNoteTypeCodeLanguageLocale = Convert.ToString(s.MicroSoftLocaleID),
                    RCReleaseNote     = s.RCReleaseNote,
                    ReleaseNoteTextId = s.ReleaseNoteTextId
                }).OrderByDescending(o => o.ReleaseNoteTextId).FirstOrDefault();

                if (releaseNote != null)
                {
                    softwareReleaseDefinition.SoftwareReleaseNoteTypeCode = releaseNote.SoftwareReleaseNoteTypeCode;
                    softwareReleaseDefinition.SoftwareReleaseNoteTypeCodeLanguageLocale = releaseNote.SoftwareReleaseNoteTypeCodeLanguageLocale;
                    softwareReleaseDefinition.RCReleaseNote = releaseNote.RCReleaseNote;
                }

                int pocPermission = (from pr in _dbEntities.POCUserRoles
                                     join pu in _dbEntities.POCUsers on pr.RoleId equals pu.RoleId
                                     where pu.UserName == UserName
                                     select pr.Permission).FirstOrDefault();
                if (pocPermission > 0)
                {
                    softwareReleaseDefinition.POCUserPermission = pocPermission;
                }
                return(Request.CreateResponse(HttpStatusCode.OK, softwareReleaseDefinition));
            }
            catch (Exception ex)
            {
                response.Content    = new StringContent("[]");
                response.StatusCode = HttpStatusCode.InternalServerError;
            }

            return(response);
        }