Example #1
0
 /// <summary>
 /// delete Recurrence Appointment 
 /// </summary>
 /// <param name="appointmentExist"></param>
 /// <param name="dropBoxLink"></param>
 /// <param name="recurrenceEditStatus"></param>
 /// <returns></returns>
 private Appointment DeleteRecurrenceAppointment(Appointment appointmentExist, DropBoxLink dropBoxLink, AppEnum.EditStatus recurrenceEditStatus)
 {
     // get the Url of Recurrence Appointment
     if (appointmentExist.Recurrence.RecurrenceList != null && appointmentExist.Recurrence.RecurrenceList.Count > 0)
     {
         string recurrenceGroupUrl = FormatRecurrenceGroupUrl(_recurrenceDocument.GetAssignmentUrl(dropBoxLink, DocumentPath.Module.RecurrenceGroup), appointmentExist.RecurrenceGroup);
         recurrenceGroupUrl = string.Format(recurrenceGroupUrl, appointmentExist.RecurrenceGroup);
         switch (recurrenceEditStatus)
         {
             case AppEnum.EditStatus.All:
                 DeleteAppointmentList(appointmentExist);
                 string deleteRecurrenceGroup;
                 _recurrenceDocument.Delete(recurrenceGroupUrl, out deleteRecurrenceGroup);
                 break;
             case AppEnum.EditStatus.Current:
                 DeleteAnAppointment(appointmentExist.Url);
                 List<string> appointmentSavedUrl = appointmentExist.Recurrence.RecurrenceList.Where(app => !(app.Equals(appointmentExist.Url))).ToList();
                 SaveAppointmentUrlRecurrenceGroup(appointmentSavedUrl, dropBoxLink, appointmentExist.RecurrenceGroup);
                 break;
         }
     }
     return appointmentExist;
 }
Example #2
0
 private void SetAuditFieldsForAppointment(string appointmentGuid, Appointment toSaveAppointment, DropBoxLink dropBoxLink)
 {
     if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuid))
     {// edit mode
         //SetAuditFields(appointmentToSave, true);
         SetClientAuditFields(toSaveAppointment, true, dropBoxLink);
         if (toSaveAppointment != null && toSaveAppointment.Recurrence != null)
         {
             //SetAuditFields(appointmentToSave.Recurrence, true);
             SetClientAuditFields(toSaveAppointment.Recurrence, true, dropBoxLink);
         }
     }
     else
     { // create mode
         //SetAuditFields(appointmentToSave, false);
         SetClientAuditFields(toSaveAppointment, false, dropBoxLink);
         if (toSaveAppointment != null && toSaveAppointment.Recurrence != null)
         {
             //SetAuditFields(appointmentToSave.Recurrence, false);
             SetClientAuditFields(toSaveAppointment.Recurrence, false, dropBoxLink);
         }
     }
 }
Example #3
0
 private void DeleteFromRecurrenceCreateNewNonRecurrenceAppointment(Appointment toSaveAppointment, DropBoxLink dropBoxLink, Appointment appointmentAlreadyExist, AppEnum.EditStatus occurenceStatus)
 {
     //Appointment deletedAppointmentExist = DeleteAppointmentType(toSaveAppointment, dropBoxLink, occurenceStatus, appointmentAlreadyExist);
     DeleteAppointmentType(toSaveAppointment, dropBoxLink, occurenceStatus, appointmentAlreadyExist);
     //toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
     //toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
     //toSaveAppointment.ChartTimeStamp = appointmentAlreadyExist.ChartTimeStamp;
     //toSaveAppointment.Signature = appointmentAlreadyExist.Signature;
     SetAppointmentAduitFieldsValues(toSaveAppointment, appointmentAlreadyExist);
     toSaveAppointment.Recurrence = null;
     SaveActualAppointment("", toSaveAppointment, dropBoxLink);
 }
Example #4
0
 /*
 private string GetWeekOfYear(DateTime appointmentDateTime)
 {
     return "W" + AppCommon.GetWeekOfYear(appointmentDateTime);
 }
 */
 private AppEnum.ProviderType GetProviderType(Appointment appointmentToSave)
 {
     AppEnum.ProviderType providerType = AppEnum.ProviderType.SingleProvider;
     if (appointmentToSave.ProviderId.Count > 1)
     {
         providerType = AppEnum.ProviderType.MultiProvider;
     }
     else if (appointmentToSave.ProviderId.Count == 1)
     {
         providerType = AppEnum.ProviderType.SingleProvider;
     }
     return providerType;
 }
Example #5
0
        private void SaveActualAppointmentRecurrence(string appointmentGuidUrl, Appointment appointmentToSave, DropBoxLink dropBoxLink)
        {
            appointmentToSave.RecurrenceGroup = SaveRecurrenceGroup(dropBoxLink, appointmentToSave.Recurrence, appointmentToSave.RecurrenceGroup);
            IList<Appointment> appointmentsListToSchedule = new List<Appointment>();
            if (appointmentToSave is PatientVisit)
            {
                IList<PatientVisit> patientVisitAppointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<PatientVisit>>(GetAppointments(appointmentToSave, AppEnum.AppointmentTypes.PatientVisit));
                appointmentsListToSchedule = patientVisitAppointmentsListToSchedule.ToList<Appointment>();
            }

            else if (appointmentToSave is BlockAppointment)
            {
                IList<BlockAppointment> blockAppointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<BlockAppointment>>(GetAppointments(appointmentToSave, AppEnum.AppointmentTypes.Block));
                appointmentsListToSchedule = blockAppointmentsListToSchedule.ToList<Appointment>();
            }
            else if (appointmentToSave is OtherAppointment)
            {
                IList<OtherAppointment> otherAppointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<OtherAppointment>>(GetAppointments(appointmentToSave, AppEnum.AppointmentTypes.Other));
                appointmentsListToSchedule = otherAppointmentsListToSchedule.ToList<Appointment>();
            }
            List<string> patientVisitSavedUrl = new List<string>();
            if (appointmentsListToSchedule.Count > 0)
            {
                foreach (Appointment appointmentItem in appointmentsListToSchedule)
                {
                    ClearAppointmentRecurrenceGroup(appointmentItem);
                    patientVisitSavedUrl.Add(SaveActualAppointment(appointmentGuidUrl, appointmentItem, dropBoxLink));
                }
            }
            SaveAppointmentUrlRecurrenceGroup(patientVisitSavedUrl, dropBoxLink, appointmentToSave.RecurrenceGroup);
        }
Example #6
0
 /// <summary>
 /// Get class names for calendar Events
 /// </summary>
 /// <param name="appointment"></param>
 /// <returns></returns>
 private string GetCalendarClassForAppointmentType(Appointment appointment)
 {
     if (appointment is PatientVisit)
     {
         return AppCommon.PatientVisitType;
     }
     if (appointment is BlockAppointment)
     {
         return AppCommon.BlockType;
     }
     return AppCommon.OtherType;
 }
Example #7
0
 /// <summary>
 /// Get tooltip value for calendar events
 /// </summary>
 /// <param name="appointment"></param>
 /// <returns></returns>
 private string GetCalendarTooltipForAppointmentType(Appointment appointment)
 {
     string tooltip = String.Empty;
     if (appointment is PatientVisit)
     {
         tooltip = AppCommon.GetPatientName(appointment.FirstName, appointment.LastName, appointment.MiddleInitial);
     }
     else if (appointment is BlockAppointment)
     {
         tooltip = appointment.Type;
     }
     else if (appointment is OtherAppointment)
     {
         tooltip = appointment.Type;
     }
     tooltip = "<span class='header-text'>"
                 + tooltip
                 + "</span>" + AppCommon.NewLineSeperator
                 + GetProviderName(appointment, AppCommon.NewLineSeperator)
                 + AppCommon.NewLineSeperator
                 + AppCommon.GetDateInGivenFormat(AppCommon.DateHMmTt, appointment.StartDateTime)
                 + AppCommon.HyphenSeperator
                 + AppCommon.GetDateInGivenFormat(AppCommon.DateHMmTt, appointment.EndDateTime);
     return tooltip;
 }
Example #8
0
 private bool CancelAppointment(string appointmentUrl, Appointment appointmentToCancel, DropBoxLink dropBoxLink, AppEnum.EditStatus occurrenceStatus)
 {
     switch (occurrenceStatus)
     {
         case AppEnum.EditStatus.All:
             CancelRecurringAppointment(appointmentUrl, appointmentToCancel, dropBoxLink);
             break;
         case AppEnum.EditStatus.None:
         case AppEnum.EditStatus.Current:
             CancelActualAppointment(appointmentUrl, appointmentToCancel, dropBoxLink);
             break;
     }
     return true;
 }
Example #9
0
 private void CancelRecurringAppointment(string appointmentUrl, Appointment appointmentExist, DropBoxLink dropBoxLink)
 {
     // get the Url of Recurrence Appointment
     Appointment appointmentToCancel = null;
     if (appointmentExist.Recurrence.RecurrenceList != null && appointmentExist.Recurrence.RecurrenceList.Count > 0)
     {
         foreach (string cancelItem in appointmentExist.Recurrence.RecurrenceList)
         {
             if (appointmentExist is PatientVisit)
             {
                 appointmentToCancel = _patientVisitAppointmentDocument.Get(cancelItem);
             }
             else if (appointmentExist is BlockAppointment)
             {
                 appointmentToCancel = _blockAppointmentDocument.Get(cancelItem);
             }
             CancelActualAppointment(appointmentUrl, appointmentToCancel, dropBoxLink);
         }
     }
 }
Example #10
0
        /// <summary>
        /// this method will be invoked by appointment controller. Base method 
        /// </summary>
        /// <param name="appointmentGuid"></param>
        /// <param name="toSaveAppointment"></param>
        /// <param name="dropBoxLink"></param>
        /// <param name="occurrenceStatus"></param>
        public string SaveAppointmentType(string appointmentGuid, Appointment toSaveAppointment, DropBoxLink dropBoxLink, AppEnum.EditStatus occurrenceStatus)
        {
            bool isDateChanged = false;
            Appointment appointmentExist = null;
            string returnString = "";

            if (toSaveAppointment is PatientVisit)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuid))
                {
                    appointmentExist = GetPatientVisitAppointment(appointmentGuid, dropBoxLink);
                    isDateChanged = CheckIsDataChange(appointmentExist, toSaveAppointment);
                }

            }
            else if (toSaveAppointment is BlockAppointment)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuid))
                {
                    appointmentExist = GetBlockAppointment(appointmentGuid, dropBoxLink);
                    isDateChanged = CheckIsDataChange(appointmentExist, toSaveAppointment);
                }
            }
            else if (toSaveAppointment is OtherAppointment)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuid))
                {
                    appointmentExist = GetOtherAppointment(appointmentGuid, dropBoxLink);
                    isDateChanged = CheckIsDataChange(appointmentExist, toSaveAppointment);
                }
            }

            if (toSaveAppointment.Status == (int)AppEnum.AppointmentStatus.Canceled)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuid))
                {
                    if (appointmentExist != null)
                    {
                        appointmentExist.ReasonForCancellation = toSaveAppointment.ReasonForCancellation;
                        CancelAppointment(appointmentGuid, appointmentExist, dropBoxLink, occurrenceStatus);
                    }
                    returnString = AppConstants.Cancelled;
                }
            }
            else
            {
                SetAuditFieldsForAppointment(appointmentGuid, toSaveAppointment, dropBoxLink);
                SaveAppointment(appointmentGuid, toSaveAppointment, dropBoxLink, isDateChanged, appointmentExist, occurrenceStatus);
                returnString = AppConstants.AppointmentSave;
            }

            return returnString;
        }
Example #11
0
 private void CancelActualAppointment(string appointmentUrl, Appointment appointmentToCancel, DropBoxLink dropBoxLink)
 {
     appointmentToCancel.Status = (int)AppEnum.AppointmentStatus.Canceled;
     //SetAuditFields(appointmentToCancel, true, dropBoxLink);
     SetClientAuditFields(appointmentToCancel, true, dropBoxLink);
     SaveActualAppointment(appointmentUrl, appointmentToCancel, dropBoxLink);
 }
Example #12
0
        /// <summary>
        /// Method to fetch the Appointment based on Dropbox and url
        /// </summary>
        /// <param name="appointmentUrl"></param>
        /// <param name="appointmentToGet"></param>
        /// <param name="dropBoxLink"></param>
        /// <returns></returns>
        public Appointment GetAppointment(string appointmentUrl, Appointment appointmentToGet, DropBoxLink dropBoxLink)
        {
            Appointment appointmentExist = null;
            if (appointmentToGet is PatientVisit)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentUrl))
                {
                    appointmentExist = GetPatientVisitAppointment(appointmentUrl, dropBoxLink);
                }

            }
            else if (appointmentToGet is BlockAppointment)
            {
                if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentUrl))
                {
                    appointmentExist = GetBlockAppointment(appointmentUrl, dropBoxLink);
                }
            }
            return appointmentExist;
        }
Example #13
0
 //private void UpdateSaveAppointmentRecurrenceToNonRecurrence(Appointment toSaveAppointment, DropBoxLink dropBoxLink, Appointment appointmentAlreadyExist)
 //{
 //    if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup))
 //    {
 //        appointmentAlreadyExist = DeleteRecurrenceAppointment(toSaveAppointment, appointmentAlreadyExist, dropBoxLink, AppEnum.EditStatus.All);
 //    }
 //    SetAuditFields(toSaveAppointment, true, dropBoxLink);
 //    toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
 //    toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
 //    SaveActualAppointment("", toSaveAppointment, dropBoxLink);
 //}
 //private void UpdateSaveAppointmentRecurrenceToRecurrence(string appointmentGuidUrl, Appointment toSaveAppointment, DropBoxLink dropBoxLink, Appointment appointmentAlreadyExist)
 //{
 //    AppEnum.ApplicationRole dropBoxLinkUserRole = AppCommon.GetCurrentUserRole(dropBoxLink.UserRole);
 //    IList<string> appointmentExistRecurrenceList = new List<string>();
 //    Appointment eachRecurrenceListAppointmentDbItem = null;
 //    if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
 //    {
 //        DateTime startDateTime = (appointmentAlreadyExist.StartDateTime.Date).Add(toSaveAppointment.StartDateTime.TimeOfDay);
 //        DateTime endDateTime = (appointmentAlreadyExist.EndDateTime.Date).Add(toSaveAppointment.EndDateTime.TimeOfDay);
 //        toSaveAppointment.StartDateTime = startDateTime;
 //        toSaveAppointment.EndDateTime = endDateTime;
 //        IList<Appointment> appointmentsListToSchedule = new List<Appointment>();
 //        if (toSaveAppointment is PatientVisit)
 //        {
 //            IList<PatientVisit> patientVisitAppointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<PatientVisit>>(GetAppointments((PatientVisit)toSaveAppointment, AppEnum.AppointmentTypes.PatientVisit));
 //            appointmentsListToSchedule = patientVisitAppointmentsListToSchedule.Cast<Appointment>().ToList<Appointment>();
 //        }
 //        else if (toSaveAppointment is BlockAppointment)
 //        {
 //            IList<BlockAppointment> blockAppointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<BlockAppointment>>(GetAppointments((BlockAppointment)toSaveAppointment, AppEnum.AppointmentTypes.Block));
 //            appointmentsListToSchedule = blockAppointmentsListToSchedule.Cast<Appointment>().ToList<Appointment>();
 //        }
 //        foreach (string appointmentItem in appointmentAlreadyExist.Recurrence.RecurrenceList)
 //        {
 //            if (toSaveAppointment is PatientVisit)
 //            {
 //                eachRecurrenceListAppointmentDbItem = _patientVisitAppointmentDocument.Get(appointmentItem);
 //            }
 //            else if (toSaveAppointment is PatientVisit)
 //            {
 //                eachRecurrenceListAppointmentDbItem = _blockAppointmentDocument.Get(appointmentItem);
 //            }
 //            Appointment toSaveAppointmentType = appointmentsListToSchedule.SingleOrDefault(pv => pv.StartDateTime.Date.Equals(eachRecurrenceListAppointmentDbItem.StartDateTime.Date));
 //            if (toSaveAppointmentType != null)
 //            {
 //                toSaveAppointmentType.CreatedBy = appointmentAlreadyExist.CreatedBy;
 //                toSaveAppointmentType.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
 //                SetAuditFields(toSaveAppointmentType, true, dropBoxLink);
 //                ClearAppointmentRecurrenceGroup(toSaveAppointmentType);
 //                toSaveAppointmentType.RecurrenceGroup = appointmentAlreadyExist.RecurrenceGroup;
 //                SaveActualAppointment(appointmentItem, toSaveAppointmentType, dropBoxLink);
 //            }
 //        }
 //    }
 //}
 /// <summary>
 /// delete  patient Visit Appointment
 /// </summary>
 /// <param name="appointmentToSave"></param>
 /// <param name="dropBoxLink"> </param>
 /// <param name="recurrenceEditStatus"></param>
 /// <param name="appointmentAlreadyExist"> </param>
 /// <returns></returns>
 public Appointment DeleteAppointmentType(Appointment appointmentToSave, DropBoxLink dropBoxLink, AppEnum.EditStatus recurrenceEditStatus, Appointment appointmentAlreadyExist)
 {
     if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.Url))
     {
         if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup))
         {// delete the single appointment
             DeleteAnAppointment(appointmentAlreadyExist.Url);
         }
         else
         {// delete the Recurrence Appointment
             appointmentAlreadyExist = DeleteRecurrenceAppointment(appointmentAlreadyExist, dropBoxLink, recurrenceEditStatus);
         }
     }
     return appointmentAlreadyExist;
 }
Example #14
0
 /// <summary>
 /// Non Recurrence To Recurrence
 /// </summary>
 /// <param name="appointmentGuidUrl"></param>
 /// <param name="toSaveAppointment"></param>
 /// <param name="dropBoxLink"></param>
 /// <param name="appointmentAlreadyExist"> </param>
 private void UpdateSaveAppointmentNonRecurrenceToRecurrence(string appointmentGuidUrl, Appointment toSaveAppointment, DropBoxLink dropBoxLink, Appointment appointmentAlreadyExist)
 {
     if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
     {
         DeleteAnAppointment(appointmentGuidUrl);
         //SetAuditFields(toSaveAppointment, true, dropBoxLink);
         SetClientAuditFields(toSaveAppointment, true, dropBoxLink);
         //toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
         //toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
         //toSaveAppointment.ChartTimeStamp = appointmentAlreadyExist.ChartTimeStamp;
         //toSaveAppointment.Signature = appointmentAlreadyExist.Signature;
         SetAppointmentAduitFieldsValues(toSaveAppointment, appointmentAlreadyExist);
         SaveActualAppointmentRecurrence("", toSaveAppointment, dropBoxLink);
     }
 }
Example #15
0
 private string GetAppointments(Appointment appointmentDocument, AppEnum.AppointmentTypes typeOfAppointment)
 {
     IAppointmentTypeStrategy appointmentType = null;
     if (typeOfAppointment == AppEnum.AppointmentTypes.PatientVisit)
     {
         //appointmentType = new PatientVisitStrategy((PatientVisit)appointmentDocument);
         appointmentType = new AppointmentStrategy<PatientVisit>((PatientVisit)appointmentDocument);
     }
     else if (typeOfAppointment == AppEnum.AppointmentTypes.Block)
     {
         //appointmentType = new BlockStrategy((BlockAppointment)appointmentDocument);
         appointmentType = new AppointmentStrategy<BlockAppointment>((BlockAppointment)appointmentDocument);
     }
     else if (typeOfAppointment == AppEnum.AppointmentTypes.Other)
     {
         //appointmentType = new BlockStrategy((BlockAppointment)appointmentDocument);
         appointmentType = new AppointmentStrategy<OtherAppointment>((OtherAppointment)appointmentDocument);
     }
     if (appointmentType != null)
     {
         return appointmentType.GenerateAppointments();
     }
     return "";
 }
Example #16
0
 /// <summary>
 /// Check if the appointment is recurrence type
 /// </summary>
 /// <param name="appointment"></param>
 /// <returns></returns>
 private bool CheckIfRecurrenceExists(Appointment appointment)
 {
     if (!String.IsNullOrEmpty(appointment.RecurrenceGroup))
     {
         return true;
     }
     return false;
 }
Example #17
0
 private string GetAppointmentType(Appointment appointment)
 {
     if (appointment is PatientVisit)
     {
         return AppEnum.AppointmentTypes.PatientVisit.ToString();
     }
     if (appointment is BlockAppointment)
     {
         return AppEnum.AppointmentTypes.Block.ToString();
     }
     return AppEnum.AppointmentTypes.Other.ToString();
 }
Example #18
0
 //public void SavePatientVisitAppointment(PatientVisit patientVisitAppointment, string courseId, AppEnum.ApplicationRole role, string assignmentScenarioId)
 //{
 //    //patientVisitAppointment.RecurrenceGroup = GetIdentifierFromUrl(_recurrenceDocument.SaveOrUpdate(FormatRecurrenceGroupUrl(_recurrenceDocument.Url, courseId, role, assignmentScenarioId), patientVisitAppointment.Recurrence));
 //    //IList<PatientVisit> appointmentsListToSchedule = JsonSerializer.DeserializeObject<IList<PatientVisit>>(GetAppointments(patientVisitAppointment, AppEnum.AppointmentTypes.PatientVisit));
 //    //patientVisitAppointment.ClearRecurrenceGroup();
 //    // _patientVisitAppointmentDocument.SaveOrUpdate(FormatAppointmentUrl(_patientVisitAppointmentDocument.Url, courseId, role, assignmentScenarioId, patientVisitAppointment.StartDateTime), patientVisitAppointment);
 //    if (patientVisitAppointment.ProviderId != null)
 //    {
 //        foreach (int item in patientVisitAppointment.ProviderId)
 //        {
 //            _patientVisitAppointmentDocument.SaveOrUpdate(FormatAppointmentUrl(_patientVisitAppointmentDocument.Url, courseId, role, assignmentScenarioId, patientVisitAppointment.StartDateTime, item.ToString()), patientVisitAppointment);
 //        }
 //    }
 //}
 private bool CheckIsDataChange(Appointment patientVisitExist, Appointment toSaveAppointment)
 {
     const bool isDataChanged = false;
     if (!patientVisitExist.StartDateTime.Equals(toSaveAppointment.StartDateTime))
     {
         return true;
     }
     if (!patientVisitExist.EndDateTime.Equals(toSaveAppointment.EndDateTime))
     {
         return true;
     }
     if (!AppCommon.IsListSame(patientVisitExist.ProviderId, toSaveAppointment.ProviderId))
     {
         return true;
     }
     if (patientVisitExist.Recurrence != null && toSaveAppointment.Recurrence != null)
     {
         if (!patientVisitExist.Recurrence.Pattern.ToString().Equals(toSaveAppointment.Recurrence.Pattern.ToString()))
         {
             return true;
         }
         if (!patientVisitExist.Recurrence.NumberOfOccurences.Equals(toSaveAppointment.Recurrence.NumberOfOccurences))
         {
             return true;
         }
     }
     return isDataChanged;
 }
Example #19
0
 /// <summary>
 /// Get Title for Calendar Tool tips
 /// </summary>
 /// <param name="appointment"></param>
 /// <param name="calenderView"></param>
 /// <returns></returns>
 private string GetCalendarTitleForAppointmentType(Appointment appointment, string calenderView)
 {
     string titleOfAppointment = string.Empty;
     if (appointment is PatientVisit)
     {
         titleOfAppointment = AppCommon.GetPatientName(appointment.FirstName, appointment.LastName, appointment.MiddleInitial);
     }
     else if (appointment is BlockAppointment)
     {
         titleOfAppointment = appointment.Type;
     }
     else if (appointment is OtherAppointment)
     {
         titleOfAppointment = appointment.Type;
     }
     string statusOfAppointment = AppCommon.GetAppointmentStatusString(appointment.Status);
     string locationOfAppointment = AppCommon.GetStatusLocationString(appointment.StatusLocation);
     if (calenderView == AppEnum.CalendarViewTypes.agendaDay.ToString())
     {
         titleOfAppointment = "<span class='header-text'>" + titleOfAppointment + "</span>" + AppCommon.SemicolonSeperator + GetProviderName(appointment, AppCommon.CommaSeperator);
         if (statusOfAppointment != String.Empty)
         {
             titleOfAppointment = titleOfAppointment + AppCommon.SemicolonSeperator + statusOfAppointment;
         }
         if (locationOfAppointment != String.Empty)
         {
             titleOfAppointment = titleOfAppointment + AppCommon.SemicolonSeperator + locationOfAppointment;
         }
     }
     else
     {
         titleOfAppointment = "<span class='header-text'>"
             + AppCommon.SliceStringAfterLength(titleOfAppointment, AppCommon.EventsTitleMaxLength) + "</span>"
             + AppCommon.NewLineSeperator
             + AppCommon.SliceStringAfterLength(GetProviderName(appointment, AppCommon.NewLineSeperator), AppCommon.EventsTitleMaxLength)
             + AppCommon.NewLineSeperator + AppCommon.SliceStringAfterLength(statusOfAppointment, AppCommon.EventsTitleMaxLength)
             + AppCommon.NewLineSeperator + AppCommon.SliceStringAfterLength(locationOfAppointment, AppCommon.EventsTitleMaxLength);
     }
     return titleOfAppointment;
 }
Example #20
0
 private void ClearAppointmentRecurrenceGroup(Appointment appointment)
 {
     appointment.ClearRecurrenceGroup();
 }
Example #21
0
 /// <summary>
 /// Get Provider name based on All staff selection.
 /// </summary>
 /// <param name="appointment"></param>
 /// <param name="delimiter"></param>
 /// <returns></returns>
 private string GetProviderName(Appointment appointment, string delimiter)
 {
     if (appointment != null)
     {
         if (appointment.IsAllStaffSelected)
         {
             return AppCommon.ProviderList.Where(s => s.Key.Equals(AppCommon.AllStaffIdentifier)).Select(s => s.Value.ToString()).SingleOrDefault();
         }
         return _masterService.GetProviderName(appointment.ProviderId, delimiter);
     }
     return String.Empty;
 }
Example #22
0
        private void DeleteAndCreateNewAppointment(Appointment toSaveAppointment, DropBoxLink dropBoxLink, Appointment appointmentAlreadyExist)
        {
            Appointment deletedAppointmentExist = DeleteAppointmentType(toSaveAppointment, dropBoxLink, AppEnum.EditStatus.All, appointmentAlreadyExist);
            //SetAuditFields(toSaveAppointment, true, dropBoxLink); //  set audit fields for modify...
            SetClientAuditFields(toSaveAppointment, true, dropBoxLink);
            //toSaveAppointment.CreatedBy = deletedAppointmentExist.CreatedBy;
            //toSaveAppointment.CreatedTimeStamp = deletedAppointmentExist.CreatedTimeStamp;
            //toSaveAppointment.ChartTimeStamp = deletedAppointmentExist.ChartTimeStamp;
            //toSaveAppointment.Signature = deletedAppointmentExist.Signature;
            SetAppointmentAduitFieldsValues(toSaveAppointment, appointmentAlreadyExist);
            if (toSaveAppointment.Recurrence == null)
            {// set audit fields for create ...
                SaveActualAppointment("", toSaveAppointment, dropBoxLink);
            }
            else
            {   // set audit fields for create ...
                if (deletedAppointmentExist.Recurrence != null)
                {// set audit fields for P.V  recurrence create ...
                    toSaveAppointment.Recurrence.CreatedBy = deletedAppointmentExist.Recurrence.CreatedBy;
                    toSaveAppointment.Recurrence.CreatedTimeStamp = deletedAppointmentExist.Recurrence.CreatedTimeStamp;
                    toSaveAppointment.Recurrence.ChartTimeStamp = deletedAppointmentExist.Recurrence.ChartTimeStamp;
                    toSaveAppointment.Recurrence.Signature = deletedAppointmentExist.Recurrence.Signature;
                    //toSaveAppointment.StartDateTime = deletedAppointmentExist.Recurrence.StartDateTime;
                    //toSaveAppointment.EndDateTime = deletedAppointmentExist.Recurrence.EndDateTime;
                }
                else
                {// set audit fields for P.V  recurrence create .. for new
                    //SetAuditFields(toSaveAppointment.Recurrence, false, dropBoxLink);
                    SetClientAuditFields(toSaveAppointment.Recurrence, false, dropBoxLink);

                }
                SaveActualAppointmentRecurrence("", toSaveAppointment, dropBoxLink);
            }
        }
Example #23
0
        private string SaveActualAppointment(string appointmentGuidUrl, Appointment appointmentToSave, DropBoxLink dropBoxLink)
        {
            AppEnum.ProviderType providerType = GetProviderType(appointmentToSave);
            string providerIntId = "";
            if (providerType == AppEnum.ProviderType.SingleProvider)
            {
                providerIntId = appointmentToSave.ProviderId[0].ToString();
            }
            if (appointmentToSave is PatientVisit)
            {
                if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
                {

                    return _patientVisitAppointmentDocument.SaveOrUpdate(FormatAppointmentUrl(_patientVisitAppointmentDocument.GetAssignmentUrl(dropBoxLink, DocumentPath.Module.PatientVisitAppointment, providerType.ToString()),
                                appointmentToSave.StartDateTime, providerIntId, appointmentGuidUrl, providerType), (PatientVisit)appointmentToSave);
                }
                return _patientVisitAppointmentDocument.SaveOrUpdate(appointmentGuidUrl, (PatientVisit)appointmentToSave);
            }
            if (appointmentToSave is BlockAppointment)
            {
                if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
                {
                    return _blockAppointmentDocument.SaveOrUpdate(FormatAppointmentUrl(_blockAppointmentDocument.GetAssignmentUrl(dropBoxLink, DocumentPath.Module.BlockAppointment, providerType.ToString()), appointmentToSave.StartDateTime, providerIntId, appointmentGuidUrl, providerType), (BlockAppointment)appointmentToSave);
                }
                return _blockAppointmentDocument.SaveOrUpdate(appointmentGuidUrl, (BlockAppointment)appointmentToSave);
            }
            if (appointmentToSave is OtherAppointment)
            {
                if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
                {
                    return _otherAppointmentDocument.SaveOrUpdate(FormatAppointmentUrl(_otherAppointmentDocument.GetAssignmentUrl(dropBoxLink, DocumentPath.Module.OtherAppointment, providerType.ToString()), appointmentToSave.StartDateTime, providerIntId, appointmentGuidUrl, providerType), (OtherAppointment)appointmentToSave);
                }
                return _otherAppointmentDocument.SaveOrUpdate(appointmentGuidUrl, (OtherAppointment)appointmentToSave);
            }
            return "";
        }
Example #24
0
 /// <summary>
 /// to delete the list appointment for Patient Visit  & Block Type
 /// </summary>
 /// <param name="appointmentExist"></param>
 private void DeleteAppointmentList(Appointment appointmentExist)
 {
     if (appointmentExist.Recurrence.RecurrenceList != null && appointmentExist.Recurrence.RecurrenceList.Count > 0)
     {
         foreach (string appItem in appointmentExist.Recurrence.RecurrenceList)
         {
             DeleteAnAppointment(appItem);
         }
     }
 }
Example #25
0
        private void SaveAppointment(string appointmentGuidUrl, Appointment toSaveAppointment, DropBoxLink dropBoxLink, bool isDateChanged, Appointment appointmentAlreadyExist, AppEnum.EditStatus occurenceStatus)
        {
            //  appointmentGuidUrl null
            if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentGuidUrl))
            { // create mode
                if (toSaveAppointment.Recurrence == null)
                { // save non Recurrence patient Visit Appointment
                    SaveActualAppointment("", toSaveAppointment, dropBoxLink);
                }
                else
                {// save Recurrence patient Visit Appointment
                    SaveActualAppointmentRecurrence("", toSaveAppointment, dropBoxLink);
                }
            }
            else
            {    // edit mode

                switch (occurenceStatus)
                {
                    case AppEnum.EditStatus.All:
                        DeleteAndCreateNewAppointment(toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                        break;
                    case AppEnum.EditStatus.Current:
                        if (isDateChanged)
                        {
                            // delete current appoint from reccurence & create new non recurring appointment
                            // from recurrence to new appointment (non-recurrence)
                            DeleteFromRecurrenceCreateNewNonRecurrenceAppointment(toSaveAppointment, dropBoxLink, appointmentAlreadyExist, occurenceStatus);
                        }
                        else
                        { // Update an appointment  from recurrence list
                            //toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
                            //toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
                            //toSaveAppointment.ChartTimeStamp = appointmentAlreadyExist.ChartTimeStamp;
                            //toSaveAppointment.Signature = appointmentAlreadyExist.Signature;
                            SetAppointmentAduitFieldsValues(toSaveAppointment, appointmentAlreadyExist);
                            toSaveAppointment.Recurrence = null;
                            toSaveAppointment.RecurrenceGroup = appointmentAlreadyExist.RecurrenceGroup;
                            SaveActualAppointment(appointmentGuidUrl, toSaveAppointment, dropBoxLink);
                        }
                        break;
                    case AppEnum.EditStatus.None:
                        //  Appointment from DB has no recurrence  but  Appointment  from edited has recurrence then  change is for Non Recurrence To Recurrence
                        if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup) && (toSaveAppointment.Recurrence != null))
                        {
                            UpdateSaveAppointmentNonRecurrenceToRecurrence(appointmentGuidUrl, toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                        }
                        //  Patient Visit from DB has no recurrence  but Patient Visit from edited has no recurrence then  change is for Non Recurrence To non Recurrence
                        else if (AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup) && (toSaveAppointment.Recurrence == null))
                        {
                            //toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
                            //toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
                            //toSaveAppointment.ChartTimeStamp = appointmentAlreadyExist.ChartTimeStamp;
                            //toSaveAppointment.Signature = appointmentAlreadyExist.Signature;

                            SetAppointmentAduitFieldsValues(toSaveAppointment, appointmentAlreadyExist);

                            if (isDateChanged)
                            {
                                DeleteAndCreateNewAppointment(toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                            }
                            else
                            {
                                SaveActualAppointment(appointmentGuidUrl, toSaveAppointment, dropBoxLink);
                            }
                        }
                        break;
                }

                //if (isDateChanged)
                //{ // if date changed in edit mode delete  all Recurrence and patient Visit Appointment list  and create new appointment
                //    DeleteAndCreateNewAppointment(appointmentGuidUrl, toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                //}
                //else
                //{ // if date not change then change need to be done only on current & fucutre date appointmnet.

                //    // Patient Visit from DB and Patient Visit from edited  both has Recurrence then  chnage is for Recurrence To Recurrence
                //    if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup) && (toSaveAppointment.Recurrence != null))
                //    {
                //        UpdateSaveAppointmentRecurrenceToRecurrence(appointmentGuidUrl, toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                //    }
                //    //  Patient Visit from DB has recurrence  but Patient Visit from edited has no recurrence then  chnage is for Recurrence To non Recurrence
                //    else if (!AppCommon.CheckIfStringIsEmptyOrNull(appointmentAlreadyExist.RecurrenceGroup) && (toSaveAppointment.Recurrence == null))
                //    {
                //        UpdateSaveAppointmentRecurrenceToNonRecurrence(toSaveAppointment, dropBoxLink, appointmentAlreadyExist);
                //    }

                //}
            }
        }
Example #26
0
 private void SetAppointmentAduitFieldsValues(Appointment toSaveAppointment, Appointment appointmentAlreadyExist)
 {
     toSaveAppointment.CreatedBy = appointmentAlreadyExist.CreatedBy;
     toSaveAppointment.CreatedTimeStamp = appointmentAlreadyExist.CreatedTimeStamp;
     toSaveAppointment.ChartTimeStamp = appointmentAlreadyExist.ChartTimeStamp;
     toSaveAppointment.Signature = appointmentAlreadyExist.Signature;
 }