public void JsonPCallback()
    {
        string Callback = Request.QueryString["jsonp"];
        if (!string.IsNullOrEmpty(Callback))
        {
            var sessionsQuery = new SessionsQuery();
            if (HttpContext.Current.Request["query"] != null)
            {
                sessionsQuery = HttpContext.Current.Request["query"].FromJson<SessionsQuery>();
            }
            sessionsQuery.CodeCampYearId = Utils.CurrentCodeCampYear;

            sessionsQuery.WithTags = true;

            if (HttpContext.Current.Request["start"] != null && HttpContext.Current.Request["limit"] != null)
            {
                sessionsQuery.Start = Convert.ToInt32(HttpContext.Current.Request["start"]);
                sessionsQuery.Limit = Convert.ToInt32(HttpContext.Current.Request["limit"]);
            }

            var listData1 = new List<SessionsResult>();
            var sessionsManager = new SessionsManager();
            //if (HttpContext.Current.User.Identity.IsAuthenticated
            // && Utils.CheckUserIsAdmin())
            {
                listData1 = sessionsManager.Get(sessionsQuery);
                for (int i = 0; i < listData1.Count; i++)
                {
                    listData1[i].AdminComments = null;
                    listData1[i].InterestCount = "";
                    listData1[i].InterestedCount = 0;
                    listData1[i].NotInterestedCount = 0;
                    listData1[i].PlanAheadCount = "";
                    listData1[i].PlanAheadCountInt = 0;
                    listData1[i].SessionEvalsResults = null;
                    listData1[i].SpeakerPictureUrl = "http://www.siliconvalley-codecamp.com/" + listData1[i].SpeakerPictureUrl;
                    listData1[i].TitleWithPlanAttend = "";
                    listData1[i].Username = "";
                    listData1[i].WillAttendCount = 0;
                    listData1[i].WikiURL = "";
                    listData1[i].SpeakersList = null;

                }
            }

            var listData2 = (from data in listData1 orderby data.SessionTime, data.Title.ToUpper() select data).ToList();

            var ret = new { success = true, rows = listData2, total = sessionsQuery.OutputTotal };
            //HttpContext.Current.Response.ContentType = "text/plain";
            //HttpContext.Current.Response.Write(ret.ToJson());

            // *** Do whatever you need
            //Response.Write(Callback + "( {\"x\":10 , \"y\":100} );");

            Response.Write(Callback + "( " + ret.ToJson() + " );");
        }

        Response.End();
    }
示例#2
0
        //  public override void Insert(LoadResult result)
        //  {
        //     base.Insert(result);
        //     if (result.Cargos != null && result.Cargos.Count > 0)
        //     {
        //        foreach (CargoResult c in result.Cargos)
        //        {
        //            c.LoadId = result.Id;
        //            CargoManager.I.Insert(c);
        //         }
        //      }
        //  }
        //
        //  public override void Update(LoadResult result)
        //  {
        //      base.Update(result);
        //      if (result.Cargos != null && result.Cargos.Count > 0)
        //      {
        //          CargoManager.I.Update(result.Cargos);
        //      }
        //  }
        public List<SessionsResult> Get(SessionsQuery query)
        {
            var meta = new CodeCampDataContext();
            IQueryable<Sessions> baseQuery = from myData in meta.Sessions select myData;
            baseQuery = BaseQueryAutoGen(baseQuery,query,false);
            IQueryable<SessionsResult> results = (from myData in baseQuery orderby myData.Id select new SessionsResult { Id= myData.Id,
                        SessionLevel_id = myData.SessionLevel_id,
                        Username = myData.Username,
                        Title = myData.Title,
                        Description = myData.Description,
                        Approved = myData.Approved,
                        Createdate = myData.Createdate == null ? null :  (DateTime?) new DateTime(myData.Createdate.Value.Ticks,DateTimeKind.Utc),
                        Updatedate = myData.Updatedate == null ? null :  (DateTime?) new DateTime(myData.Updatedate.Value.Ticks,DateTimeKind.Utc),
                        AdminComments = myData.AdminComments,
                        InterentAccessRequired = myData.InterentAccessRequired,
                        LectureRoomsId = myData.LectureRoomsId,
                        SessionTimesId = myData.SessionTimesId
            });

            List<SessionsResult> resultList = GetFinalResults(results, query);
            return resultList;
        }
示例#3
0
        public List<SessionsResult> Get(SessionsQuery query)
        {
            if (query.CodeCampYearId.HasValue)
            {
                query.CodeCampYearIds = new List<int>() { query.CodeCampYearId.Value};
            }

            var meta = new CodeCampDataContext();

            IQueryable<Sessions> baseQuery = from myData in meta.Sessions
                                             select myData;

            // .Where(a => a.Id == 594).ToList();
            baseQuery = BaseQueryAutoGen(baseQuery, query);

            if (query.SkipRoomIds != null && query.SkipRoomIds.Any())
            {
                baseQuery = from data in baseQuery
                            where data.LectureRoomsId.HasValue && !query.SkipRoomIds.Contains(data.LectureRoomsId.Value)
                            select data;
            }

            if (query.RoomIds != null && query.RoomIds.Any())
            {
                baseQuery = from data in baseQuery
                            where data.LectureRoomsId.HasValue && query.RoomIds.Contains(data.LectureRoomsId.Value)
                            select data;
            }

            var sessionIdsPlanToAttend = new List<int>();
            var sessionIdsInterested = new List<int>();
            if (query.WithInterestOrPlanToAttend != null &&  HttpContext.Current != null && HttpContext.Current.User.Identity.IsAuthenticated )
            {
                string username = HttpContext.Current.User.Identity.Name;

                Guid? PKID = (from data in meta.Attendees
                            where data.Username.Equals(username)
                            select data.PKID).FirstOrDefault();
                if (PKID != null)
                {
                    sessionIdsPlanToAttend = (from data in meta.SessionAttendee
                                              where data.Interestlevel == 3 && data.Attendees_username == PKID.Value
                                              select data.Sessions_id).ToList();

                    sessionIdsInterested = (from data in meta.SessionAttendee
                                              where data.Interestlevel == 2 && data.Attendees_username == PKID.Value
                                              select data.Sessions_id).ToList();
                }
            }

            if (query.CodeCampYearIds != null && query.CodeCampYearIds.Count > 0)
            {
                baseQuery = baseQuery.Where(data => query.CodeCampYearIds.Contains(data.CodeCampYearId));
            }

            List<int> sponsorIdsWithActiveJobs;
            if (query.JustActiveJobListings != null && query.JustActiveJobListings.Value)
            {
                sponsorIdsWithActiveJobs = (from data in meta.SponsorListJobListing
                                            where data.StartRunDate.HasValue && data.EndRunDate.HasValue &&
                                                  data.StartRunDate.Value.CompareTo(DateTime.Now) < 0 &&
                                                  data.EndRunDate.Value.CompareTo(DateTime.Now) > 0 &&
                                                  data.HideListing == false
                                            select data.SponsorListId).ToList();
                baseQuery =
                    baseQuery.Where(
                        data => data.SponsorId != null && sponsorIdsWithActiveJobs.Contains(data.SponsorId.Value));
            }

            var speakerResults = new List<AttendeesResult>();
            var sessionPresenterResults =new List<SessionPresenterResult>();
            if (query.WithSpeakers != null && query.WithSpeakers.Value)
            {
                //var attendeesQuery = new AttendeesQuery
                //                         {
                //                             PresentersOnly = true
                //                         };
                var sessionPresenterQuery = new SessionPresenterQuery();

                if (query.CodeCampYearIds != null && query.CodeCampYearIds.Count > 0)
                {
                    //attendeesQuery.CodeCampYearIds = query.CodeCampYearIds;
                    sessionPresenterQuery.CodeCampYearIds = query.CodeCampYearIds;
                    //attendeesQuery.CodeCampYearIds = query.CodeCampYearIds;
                }

                sessionPresenterResults = SessionPresenterManager.I.Get(sessionPresenterQuery);

                List<int> speakerIdsAll = sessionPresenterResults.Select(a => a.AttendeeId).ToList();

                speakerResults = AttendeesManager.I.Get(new AttendeesQuery()
                                                            {
                                                                Ids = speakerIdsAll
                                                            });
            }

            IQueryable<SessionsResult> results = GetBaseResultIQueryable(baseQuery);

            List<SessionsResult> resultList = GetFinalResults(results, query);

            var tagsResults = new List<TagsResult>();
             var sessionTagsManagers = new List<SessionTagsResult>();

            if (query.WithTags != null && query.WithTags.Value)
            {
                tagsResults = TagsManager.I.GetAll(); // could be smarter, but not that many tags
                sessionTagsManagers = SessionTagsManager.I.GetAll();
            }

            //// next several lines are just for the single speaker that is associated with the session. not the multiple speaker option
            //List<int> speakerIds = (resultList.Select(data => data.Attendeesid)).ToList();
            //var presentersQuery = from attend in meta.Attendees
            //                      where speakerIds.Contains(attend.Id)
            //                      select new
            //                      {
            //                          attend.Id,
            //                          SpeakerName = attend.UserFirstName + " " + attend.UserLastName,
            //                          attend.UserWebsite,
            //                          attend.PKID
            //                      };
            //var speakerDict =
            //    presentersQuery.ToDictionary(presenter => presenter.Id, presenter => presenter.SpeakerName);
            //var speakerUrlDict = new Dictionary<int, string>();
            //var speakerImageUrl = new Dictionary<int, string>();
            //foreach (var presenter in presentersQuery)
            //{
            //    speakerUrlDict.Add(presenter.Id, presenter.UserWebsite);
            //    speakerImageUrl.Add(presenter.Id,presenter.PKID.ToString());
            //}

            var lectureRoomsDict = (from data in meta.LectureRooms select data).ToDictionary(k => k.Id, v => v.Number);
            var sessionTimesDict = (from data in meta.SessionTimes select data).ToDictionary(k => k.Id, v => v.StartTimeFriendly);

            var planCountsDict = (from data in meta.SessionAttendee
                                  where data.Interestlevel == 3
                                  group data by data.Sessions_id
                                      into g
                                      orderby g.Key ascending
                                      select new { cnt = g.Count(), id = g.Key }).ToDictionary(k => k.id, v => v.cnt);

            var interestCountsDict = (from data in meta.SessionAttendee
                                  where data.Interestlevel == 2
                                  group data by data.Sessions_id
                                      into g
                                      orderby g.Key ascending
                                      select new { cnt = g.Count(), id = g.Key }).ToDictionary(k => k.id, v => v.cnt);

            var sessionTimesFullDict = new Dictionary<int, SessionTimes>();
            if (query.WithSchedule != null)
            {
                sessionTimesFullDict =
                    (from data in meta.SessionTimes
                     select data).ToDictionary(k => k.Id, v => v);
            }

            var sessionLevelsDict = new Dictionary<int, string>();
            if (query.WithLevel.HasValue && query.WithLevel.Value)
            {

                sessionLevelsDict = (from data in meta.SessionLevels
                                 select data).ToDictionary(k => k.Id, v => v.Description);
            }

            foreach (var session in resultList)
            {

                if (query.WithLevel.HasValue && query.WithLevel.Value)
                {
                    if (session.SessionLevel_id.HasValue && sessionLevelsDict.ContainsKey(session.SessionLevel_id.Value))
                    {
                        session.SessionLevel = sessionLevelsDict[session.SessionLevel_id.Value];
                    }
                }

                session.SessionUrl =
                    String.Format("/Session/{0}/{1}",
                                  Utils.ConvertCodeCampYearToActualYear(
                                      session.CodeCampYearId.ToString(CultureInfo.InvariantCulture)),
                                  Utils.GenerateSlug(session.Title));

                if (query.WithSchedule != null && session.SessionTimesId.HasValue)
                {
                    if (sessionTimesFullDict.ContainsKey(session.SessionTimesId.Value))
                    {
                        var st = sessionTimesFullDict[session.SessionTimesId.Value];
                        session.SessionTimesResult = new SessionTimesResult()
                            {
                                // no doing all the parameters, not necessary
                                CodeCampYearId = st.CodeCampYearId,
                                StartTime = st.StartTime,
                                EndTime = st.EndTime,
                                Id = st.Id,
                                Description = st.Description
                            };
                    }
                }

                if (query.WithInterestOrPlanToAttend != null)
                {
                    if (sessionIdsInterested.Contains(session.Id))
                    {
                        session.LoggedInUserInterested = true;
                    }

                    if (sessionIdsPlanToAttend.Contains(session.Id))
                    {
                        session.LoggedInUserPlanToAttend = true;
                    }
                }

                if (session.Createdate != null)
                {
                    var ts = DateTime.Now.Subtract(session.Createdate.Value);
                    session.SessionPosted = (ts.Days + 1).ToString(CultureInfo.InvariantCulture);
                }
                else
                {
                    session.SessionPosted = "Up";
                }

                // http://localhost:5691/Web/DisplayImage.ashx?sizex=100&PKID=33a199dd-1154-45cb-bc94-40ffc5a99391
                // (the next 3 lines maybe overwritten if speaker is set to be removed)

                // GOING FORWARD WE DON'T WANT TO USE SINGLE PICTURE FOR SESSIONS SPEAKER SINCE CAN HAVE MULTIPLE SPEAKERS
                //session.SpeakerPictureUrl = String.Format("DisplayImage.ashx?sizex=150&PKID={0}", speakerImageUrl[session.Attendeesid]);
                //session.PresenterName = speakerDict[session.Attendeesid];
                //session.PresenterURL = speakerUrlDict[session.Attendeesid];
                session.SpeakerPictureUrl = "DO NOT USE, USE SpeakersList instead";
                session.PresenterName = "DO NOT USE, USE SpeakersList instead";
                session.PresenterURL = "DO NOT USE, USE SpeakersList instead";

                if (query.WithSpeakers != null && query.WithSpeakers.Value)
                {
                    SessionsResult session1 = session;
                    var speakerIdsForList =
                        sessionPresenterResults.Where(a => a.SessionId == session1.Id)
                                               .Select(a => a.AttendeeId)
                                               .ToList();

                    // quick and dirty cleansing of speaker data so just public data will be shown
                    var tempSpeakerResults =
                        Enumerable.OrderBy(speakerResults.Where(a => speakerIdsForList.Contains(a.Id)),
                                           a => a.UserLastName == null ? string.Empty : a.UserLastName.ToUpper());
                    session.SpeakersList = new List<SpeakerResult>();
                    foreach (var rec in tempSpeakerResults)
                    {
                        //// need to figure out if removing primary speaker is necessary
                        //if (session.DoNotShowPrimarySpeaker)
                        //{
                        //    string userNameOfSpeakerFromSession = session.Username;
                        //    string userNameOfSpeakerFromSessionSpeaker = rec.Username;
                        //    if (!userNameOfSpeakerFromSession.Equals(userNameOfSpeakerFromSessionSpeaker))
                        //    {
                        //        session.SpeakersList.Add(new AttendeesResult()
                        //        {
                        //            Id = rec.Id,
                        //            Email = rec.Email,
                        //            TwitterHandle = rec.TwitterHandle,
                        //            Username = rec.Username,
                        //            City = rec.City,
                        //            State = rec.State,
                        //            UserBio = rec.UserBio,
                        //            UserFirstName = rec.UserFirstName,
                        //            UserLastName = rec.UserLastName,
                        //            UserZipCode = rec.UserZipCode,
                        //            UserWebsite = rec.UserWebsite,
                        //            SpeakerPictureUrl =
                        //                String.Format(
                        //                    String.Format("attendeeimage/{0}.jpg", rec.Id),
                        //                    rec.Id)
                        //        });

                        //        // kind of klugy if there are more than 2 speakers, but for now, we should push someone who is not the primary speaker
                        //        // into the primary slot.
                        //        session.Username = "******";
                        //        session.PresenterName = "DO NOT USE THIS. USE SpeakersList instead";
                        //        session.PresenterURL = rec.UserWebsite;
                        //        session.SpeakerPictureUrl = "DO NOT USE THIS. USE SpeakersList instead";
                        //    }
                        //}
                        //else
                        //{
                        var attendeeResult = new SpeakerResult()
                            {
                                AttendeeId = rec.Id,
                                Email = rec.Email,
                                TwitterHandle = rec.TwitterHandle,
                                Username = rec.Username,
                                City = "",
                                State = rec.State,
                                UserBio = rec.UserBio,
                                UserBioEllipsized = Utils.GetEllipsized(rec.UserBio, 90, "..."),
                                UserFirstName = rec.UserFirstName,
                                UserLastName = rec.UserLastName,
                                UserZipCode = rec.UserZipCode,
                                UserWebsite = rec.UserWebsite,
                                SpeakerLocalUrl = String.Format("/Presenter/{0}/{1}-{2}-{3}",
                                                                Utils
                                                                    .ConvertCodeCampYearToActualYear
                                                                    (session.CodeCampYearId.ToString(
                                                                        CultureInfo.InvariantCulture)),
                                                                Utils.AlphaNumericOnly(
                                                                    rec.UserFirstName),
                                                                Utils.AlphaNumericOnly(
                                                                    rec.UserLastName),
                                                                rec.Id),
                                ImageUrl =
                                    String.Format(
                                        String.Format("/attendeeimage/{0}.jpg", rec.Id),
                                        rec.PKID)

                            };

                        session.SpeakersList.Add(attendeeResult);
                        //}
                    }

                    // need to update speakersshort

                    var sbSpeakersShort = new StringBuilder();
                    if (session.SpeakersList.Count > 0 && session.SpeakersList.Count <= 1)
                    {
                        session.SpeakersShort = session.SpeakersList[0].UserFirstName + " " +
                                                session.SpeakersList[0].UserLastName;
                    }
                    else if (session.SpeakersList.Count > 1)
                    {
                        foreach (var speaker in session.SpeakersList)
                        {
                            sbSpeakersShort.Append(speaker.UserLastName);
                            sbSpeakersShort.Append(", ");
                        }
                        session.SpeakersShort = sbSpeakersShort.ToString().Trim();
                        if (session.SpeakersShort.Length > 2)
                        {
                            session.SpeakersShort.Remove(session.SpeakersShort.Length - 2);
                        }
                    }
                    else
                    {
                        session.SpeakersShort = "Unknown Speaker";
                    }
                    //session.SpeakersList = speakerResults.Where(a => speakerIdsForList.Contains(a.Id)).ToList();
                }

                session.RoomNumber = session.LectureRoomsId != null &&
                                     lectureRoomsDict.ContainsKey(session.LectureRoomsId.Value)
                                         ? lectureRoomsDict[session.LectureRoomsId.Value]
                                         : "ROOM NOT FOUND/PROBLEM!";
                session.RoomNumberNew = session.RoomNumber;

                session.SessionTime = session.SessionTimesId != null &&
                                      sessionTimesDict.ContainsKey(session.SessionTimesId.Value)
                                          ? sessionTimesDict[session.SessionTimesId.Value]
                                          : "TIME NOT FOUND/PROBLEM!";

                session.TitleWithPlanAttend = planCountsDict.ContainsKey(session.Id)
                                                  ? string.Format("PA: {0} {1}  ", planCountsDict[session.Id],
                                                                  session.Title)
                                                  : "PS: 0   " + session.Title;
                if (planCountsDict.ContainsKey(session.Id))
                {
                    session.PlanAheadCount = planCountsDict[session.Id].ToString();
                    session.PlanAheadCountInt = planCountsDict[session.Id];
                }
                else
                {
                    session.PlanAheadCount = "SessionId: " + session.Id + " Not Found";
                    session.PlanAheadCountInt = 0;
                }

                if (interestCountsDict.ContainsKey(session.Id))
                {
                    session.InterestCount = interestCountsDict[session.Id].ToString();
                    session.InterestCountInt = interestCountsDict[session.Id];
                }
                else
                {
                    session.PlanAheadCount = "SessionId: " + session.Id + " Not Found";
                    session.PlanAheadCountInt = 0;
                }

                if (query.WithTags != null && query.WithTags.Value)
                {
                    List<int> tagIds =
                        sessionTagsManagers.Where(a => a.SessionId == session.Id).Select(a => a.TagId).ToList();
                    session.TagsResults = (tagsResults.Where(data => tagIds.Contains(data.Id))).ToList();
                    foreach (var r in session.TagsResults)
                    {
                        r.SessionId = session.Id;
                    }
                }

                session.SessionSlug = Utils.GenerateSlug(session.Title);

                session.TitleEllipsized = Utils.GetEllipsized(session.Title, 48, "...");
                session.DescriptionEllipsized = Utils.GetEllipsized(session.Description, 90, "...");

            }

            return resultList;
        }
        /// <summary>
        /// route like implementation of Get.  If no parameters then get all sessions.  
        /// option = BySpeaker with param1 = "#" gives all sessions for given speaker
        /// </summary>
        /// <param name="option"></param>
        /// <param name="param1"></param>
        /// <param name="param2"></param>
        /// <param name="param3"></param>
        /// <returns></returns>
        public HttpResponseMessage Get(string option,string param1,string param2,string param3)
        {
            HttpResponseMessage response = null;

            SessionsQuery sessionQuery = null;

            if (String.IsNullOrEmpty(option))
            {
                sessionQuery = new SessionsQuery();
                response = Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, "Did not pass in option variable");
            }

            else if (option.ToLower().Equals("byspeaker") && !String.IsNullOrEmpty(param1))
            {
                int attendeesId;
                if (!Int32.TryParse(param1, out attendeesId))
                {
                    attendeesId = -2;
                }

                int codeCampYearId; // current year
                if (!Int32.TryParse(param2, out codeCampYearId))
                {
                    codeCampYearId = -1;
                }

                if (codeCampYearId == -1)
                {
                    codeCampYearId = Utils.GetCurrentCodeCampYear();
                }

                List<int> sessionIds = SessionPresenterManager.I.Get(new SessionPresenterQuery
                                                                                {
                                                                                    AttendeeId = attendeesId,
                                                                                    CodeCampYearId = codeCampYearId
                                                                                }).Select(a => a.SessionId).ToList();
                sessionQuery = new SessionsQuery
                                   {
                                      Ids = sessionIds,
                                      WithLevel = true
                                   };

                List<SessionsResult> session = SessionsManager.I.Get(sessionQuery);
                foreach (var rec in session)
                {
                    rec.Title = rec.Title.Trim(); // just making sure because we use this for unique stuff
                }
                response = Request.CreateResponse(HttpStatusCode.OK, session);
            }
            else if (option.ToLower().Equals("justlowercasetitle"))
            {
                List<SessionsResult> sessionsFull = SessionsManager.I.Get(new SessionsQuery()
                    {
                        CodeCampYearId = Utils.CurrentCodeCampYear
                    });

                List<SessionsResult>  sessionTitles = sessionsFull.Select(rec => new SessionsResult()
                    {
                        Id = rec.Id,
                        Title = rec.Title.ToLower().Trim()
                    }).ToList();

                response = Request.CreateResponse(HttpStatusCode.OK, sessionTitles);
            }

            return response;
        }