public ActionResult EditChoice(int?id, bool?WhichEdit)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ScheduleParameters scheduleParameters = db.ScheduleParameters.Find(id);
if (scheduleParameters == null)
{
return(HttpNotFound());
}
if (WhichEdit == true)
{
return(RedirectToAction("EditMax", new { ID = id }));
}
if (scheduleParameters.Day == null)
{
return(RedirectToAction("EditWeek", new { ID = id }));
}
else
{
return(RedirectToAction("EditDay", new { ID = id }));
}
}
public ActionResult DeleteConfirmed(int id)
{
ScheduleParameters scheduleParameters = db.ScheduleParameters.Find(id);
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
HsDelete.SpecialFixedFshiftDeletion();
if (scheduleParameters.Day == null)
{
SperW.NumOfShifts -= scheduleParameters.Morning * 7;
SperW.NumOfShifts -= scheduleParameters.Afternoon * 7;
SperW.NumOfShifts -= scheduleParameters.Night * 7;
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
else
{
SperW.NumOfShifts -= Convert.ToInt32(scheduleParameters.DMorning);
SperW.NumOfShifts -= Convert.ToInt32(scheduleParameters.DAfternoon);
SperW.NumOfShifts -= Convert.ToInt32(scheduleParameters.DNight);
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
db.ScheduleParameters.Remove(scheduleParameters);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//######################################
// GetSchedulesInternal
//######################################
internal List <Schedule> GetSchedulesInternal(ScheduleParameters parameters)
{
var schedules = ObjectEngine.GetObjects <Schedule>(parameters);
foreach (var schedule in schedules)
{
var response = GetObjectPropertiesRawInternal(schedule.Id, ObjectType.Schedule);
ResponseParser.LoadTimeTable(schedule, response);
}
return(schedules);
}
internal async Task <List <Schedule> > GetSchedulesInternalAsync(ScheduleParameters parameters)
{
var schedules = await ObjectEngine.GetObjectsAsync <Schedule>(parameters).ConfigureAwait(false);
await Task.WhenAll(schedules.Select(async schedule =>
{
var response = await GetObjectPropertiesRawInternalAsync(schedule.Id, ObjectType.Schedule).ConfigureAwait(false);
ResponseParser.LoadTimeTable(schedule, response);
})).ConfigureAwait(false);
return(schedules);
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ScheduleParameters scheduleParameters = db.ScheduleParameters.Find(id);
if (scheduleParameters == null)
{
return(HttpNotFound());
}
return(View(scheduleParameters));
}
public ActionResult EditDay(int?id, bool?whattodo)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ScheduleParameters scheduleParameters = db.ScheduleParameters.Find(id);
if (scheduleParameters == null)
{
return(HttpNotFound());
}
if (whattodo == true)
{
ModelState.AddModelError("DMorning", "Positive Numbers only");
return(View(scheduleParameters));
}
return(View(scheduleParameters));
}
/// <summary>
/// Gets the payment schedule.
/// </summary>
/// <param name="scheduleParameters">The schedule parameters.</param>
/// <param name="person">The person.</param>
/// <returns></returns>
private PaymentSchedule GetPaymentSchedule(ScheduleParameters scheduleParameters, Person person)
{
if (!scheduleParameters.StartDate.HasValue)
{
GenerateResponse(HttpStatusCode.BadRequest, "Schedule must contain a StartDate");
return(null);
}
var timeSpan = DateTime.Now - scheduleParameters.StartDate.Value;
if (timeSpan > TimeSpan.FromDays(0))
{
GenerateResponse(HttpStatusCode.BadRequest, "Schedule must contain a StartDate that occurs in the future");
return(null);
}
if (!scheduleParameters.FrequencyValueGuid.HasValue)
{
GenerateResponse(HttpStatusCode.BadRequest, "Schedule must contain a FrequencyValueGuid");
return(null);
}
var frequency = DefinedValueCache.Read(scheduleParameters.FrequencyValueGuid.Value);
if (frequency == null)
{
GenerateResponse(HttpStatusCode.BadRequest, "Schedule must contain a valid FrequencyValueGuid");
return(null);
}
return(new PaymentSchedule {
PersonId = person.Id,
StartDate = scheduleParameters.StartDate.Value,
TransactionFrequencyValue = frequency
});
}
public ActionResult Create(ScheduleParameters scheduleParameters)
{
int TotalShifts = 0;
int idnum = 0;
if (Convert.ToInt32(scheduleParameters.DMorning) < 0 || Convert.ToInt32(scheduleParameters.DAfternoon) < 0 || Convert.ToInt32(scheduleParameters.DNight) < 0)
{
return(RedirectToAction("DayCreate", new { whattodo = false }));
}
if (scheduleParameters.Day != null && db.ScheduleParameters.Select(o => o.Day != null).Count() > 7)
{
return(RedirectToAction("DayCreate", new { whattodo = true }));
}
if (scheduleParameters.Day == null & (Convert.ToInt32(scheduleParameters.DMorning) != 0 || Convert.ToInt32(scheduleParameters.DAfternoon) != 0 || Convert.ToInt32(scheduleParameters.DNight) != 0))
{
return(RedirectToAction("DayCreate", new { whattodo = true, require = true }));
}
if (db.ScheduleParameters.Where(d => d.Day == scheduleParameters.Day).Count() > 0)
{
return(RedirectToAction("DayCreate", new { dayexists = true }));
}
HsDelete.SpecialFixedFshiftDeletion();
if (db.ShiftsPerWeek.Any())
{
idnum = db.ShiftsPerWeek.FirstOrDefault().ID;
}
if (scheduleParameters.Day == null)
{
if (idnum == 0)
{
ShiftsPerWeek SPW = new ShiftsPerWeek
{
NumOfShifts = (scheduleParameters.Morning + scheduleParameters.Afternoon + scheduleParameters.Night) * 7
};
db.ShiftsPerWeek.Add(SPW);
db.SaveChanges();
}
else
{
ShiftsPerWeek EditOldShift = db.ShiftsPerWeek.Find(idnum);
EditOldShift.NumOfShifts = (scheduleParameters.Morning + scheduleParameters.Afternoon + scheduleParameters.Night) * 7;
db.Entry(EditOldShift).State = EntityState.Modified;
db.SaveChanges();
}
}
else
{
scheduleParameters.DMorning = scheduleParameters.DMorning == null ? 0 : scheduleParameters.DMorning;
scheduleParameters.DAfternoon = scheduleParameters.DAfternoon == null ? 0 : scheduleParameters.DAfternoon;
scheduleParameters.DNight = scheduleParameters.DNight == null ? 0 : scheduleParameters.DNight;
TotalShifts += Convert.ToInt32(scheduleParameters.DMorning);
TotalShifts += Convert.ToInt32(scheduleParameters.DAfternoon);
TotalShifts += Convert.ToInt32(scheduleParameters.DNight);
TotalShifts += db.ShiftsPerWeek.Select(y => y.NumOfShifts).FirstOrDefault();
ShiftsPerWeek SperW = db.ShiftsPerWeek.Find(idnum);
SperW.NumOfShifts = TotalShifts;
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
if (ModelState.IsValid)
{
db.ScheduleParameters.Add(scheduleParameters);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(scheduleParameters));
}
public ActionResult Edit(ScheduleParameters scheduleParameters, bool?WhichEdit)
{
HsDelete.SpecialFixedFshiftDeletion();
if (WhichEdit == true)
{
scheduleParameters.Morning = db.ScheduleParameters.Select(x => x.Morning).FirstOrDefault();
scheduleParameters.Afternoon = db.ScheduleParameters.Select(x => x.Afternoon).FirstOrDefault();
scheduleParameters.Night = db.ScheduleParameters.Select(x => x.Night).FirstOrDefault();
if (scheduleParameters.MaxMorning < 0 || scheduleParameters.MaxAfternoon < 0 || scheduleParameters.MaxNight < 0)
{
return(RedirectToAction("EditMax", new { scheduleParameters.ID, whattodo = true }));
}
}
if (scheduleParameters.Day == null && WhichEdit == null)
{
if (scheduleParameters.Morning < 0 || scheduleParameters.Afternoon < 0 || scheduleParameters.Night < 0)
{
return(RedirectToAction("EditWeek", new { scheduleParameters.ID, whattodo = true }));
}
scheduleParameters.MaxMorning = db.ScheduleParameters.Select(x => x.MaxMorning).FirstOrDefault();
scheduleParameters.MaxAfternoon = db.ScheduleParameters.Select(x => x.MaxAfternoon).FirstOrDefault();
scheduleParameters.MaxNight = db.ScheduleParameters.Select(x => x.MaxNight).FirstOrDefault();
if (scheduleParameters.Morning != db.ScheduleParameters.Select(x => x.Morning).FirstOrDefault())
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += (scheduleParameters.Morning - db.ScheduleParameters.Select(x => x.Morning).FirstOrDefault()) * 7;
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
if (scheduleParameters.Afternoon != db.ScheduleParameters.Select(x => x.Afternoon).FirstOrDefault())
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += (scheduleParameters.Afternoon - db.ScheduleParameters.Select(x => x.Afternoon).FirstOrDefault()) * 7;
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
if (scheduleParameters.Night != db.ScheduleParameters.Select(x => x.Night).FirstOrDefault())
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += (scheduleParameters.Night - db.ScheduleParameters.Select(x => x.Night).FirstOrDefault()) * 7;
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
}
else if (scheduleParameters.Day != null && WhichEdit == null)
{
if (scheduleParameters.DMorning < 0 || scheduleParameters.DAfternoon < 0 || scheduleParameters.DNight < 0)
{
return(RedirectToAction("EditDay", new { scheduleParameters.ID, whattodo = true }));
}
if (scheduleParameters.DMorning != 0)
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += Convert.ToInt32(scheduleParameters.DMorning);
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
if (scheduleParameters.DAfternoon != 0)
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += Convert.ToInt32(scheduleParameters.DAfternoon);
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
if (scheduleParameters.DNight != 0)
{
ShiftsPerWeek SperW = db.ShiftsPerWeek.FirstOrDefault();
SperW.NumOfShifts += Convert.ToInt32(scheduleParameters.DNight);
db.Entry(SperW).State = EntityState.Modified;
db.SaveChanges();
}
}
if (ModelState.IsValid)
{
db.Entry(scheduleParameters).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(scheduleParameters));
}
/// <summary>
/// Gets the payment schedule.
/// </summary>
/// <param name="scheduleParameters">The schedule parameters.</param>
/// <param name="person">The person.</param>
/// <returns></returns>
private PaymentSchedule GetPaymentSchedule( ScheduleParameters scheduleParameters, Person person )
{
if ( !scheduleParameters.StartDate.HasValue )
{
GenerateResponse( HttpStatusCode.BadRequest, "Schedule must contain a StartDate" );
return null;
}
var timeSpan = DateTime.Now - scheduleParameters.StartDate.Value;
if ( timeSpan > TimeSpan.FromDays( 0 ) )
{
GenerateResponse( HttpStatusCode.BadRequest, "Schedule must contain a StartDate that occurs in the future" );
return null;
}
if ( !scheduleParameters.FrequencyValueGuid.HasValue )
{
GenerateResponse( HttpStatusCode.BadRequest, "Schedule must contain a FrequencyValueGuid" );
return null;
}
var frequency = DefinedValueCache.Read( scheduleParameters.FrequencyValueGuid.Value );
if ( frequency == null )
{
GenerateResponse( HttpStatusCode.BadRequest, "Schedule must contain a valid FrequencyValueGuid" );
return null;
}
return new PaymentSchedule {
PersonId = person.Id,
StartDate = scheduleParameters.StartDate.Value,
TransactionFrequencyValue = frequency
};
}
public HttpResponseMessage NextCallPost([FromBody] AgentParameters agent)
{
try
{
if (MainObject.MainList.ContainsKey(agent.User.AgentId))
{
CApp mpApp = MainObject.MainList[agent.User.AgentId];
if (mpApp.CurrentService.RequireDisposition)
{
if (agent.DispositionClass != null)
{
CDisposition pDisp;
if (mpApp.CurrentCall != null && mpApp.CurrentCall.CurrentState is CStatePreview)
{
pDisp = new CDisposition(agent.DispositionClass.Id, agent.DispositionClass.Description,
agent.DispositionClass.Code, true, false, false);
}
else
{
pDisp = new CDisposition(agent.DispositionClass.Id, agent.DispositionClass.Description,
agent.DispositionClass.Code, false, false, false);
}
try
{
if (agent.DispositionClass.Id == 1005 || agent.DispositionClass.Id == 1006)
{
string nameCustomer = mpApp.CurrentCall.FirstName;
string phonenumber = mpApp.CurrentCall.PhoneNumber;
mpApp.ScheduleCallback(mpApp.CurrentCall, pDisp, agent.DispositionClass.Date);
mpApp.DisposeCall(mpApp.CurrentCall, pDisp);
ScheduleParameters scheduleparameters = new ScheduleParameters();
scheduleparameters.Id_Disposition = pDisp.Id;
scheduleparameters.Description_Disposition = pDisp.Description;
scheduleparameters.Name_Customer = nameCustomer;
scheduleparameters.PhoneNumber = phonenumber;
scheduleparameters.AgentId = agent.User.AgentId;
scheduleparameters.Date_Schedule = agent.DispositionClass.Date;
return(Request.CreateResponse(HttpStatusCode.OK, scheduleparameters));
}
else
{
mpApp.DisposeCall(mpApp.CurrentCall, pDisp);
return(Request.CreateResponse(HttpStatusCode.OK, "OK"));
}
}
catch (Exception ex)
{
Log.logException(ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
else
{
try
{
mpApp.DisposeCall(mpApp.CurrentCall, null);
return(Request.CreateResponse(HttpStatusCode.OK, "OK"));
}
catch (Exception ex)
{
Log.logException(ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Not Require Disposition"));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Agent Not Found"));
}
}
catch (Exception ex)
{
Log.logException(ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public void RemoveParameter()
{
ScheduleParameters.Remove(ScheduleParametersSelectedItem);
NotifyOfPropertyChange(() => CanRemoveParameter);
}
public HttpResponseMessage ScheduleGiving([FromBody] ScheduleParameters scheduleParameters)
{
var rockContext = new RockContext();
try
{
rockContext.WrapTransaction(() =>
{
var person = GetExistingPerson(scheduleParameters.PersonId, rockContext);
if (person == null)
{
GenerateResponse(HttpStatusCode.BadRequest, "An existing person is required to schedule giving");
}
var totalAmount = CalculateTotalAmount(scheduleParameters, rockContext);
var paymentSchedule = GetPaymentSchedule(scheduleParameters, person);
var gatewayComponent = GatewayContainer.GetComponent(gatewayName);
if (gatewayComponent == null)
{
GenerateResponse(HttpStatusCode.InternalServerError, "There was a problem creating the gateway component");
}
var financialGateway = new FinancialGatewayService(rockContext).Queryable().FirstOrDefault(g => g.EntityTypeId == gatewayComponent.EntityType.Id);
if (financialGateway == null)
{
GenerateResponse(HttpStatusCode.InternalServerError, "There was a problem creating the financial gateway");
}
var savedAccount = GetExistingSavedAccount(scheduleParameters, person, rockContext);
FinancialPaymentDetail paymentDetail = null;
PaymentInfo paymentInfo = null;
int?locationId = null;
if (savedAccount == null)
{
locationId = CreateLocation(scheduleParameters, rockContext);
paymentDetail = CreatePaymentDetail(scheduleParameters, person, locationId.Value, rockContext);
savedAccount = CreateSavedAccount(scheduleParameters, paymentDetail, financialGateway, person, rockContext);
paymentInfo = GetPaymentInfo(scheduleParameters, person, rockContext, totalAmount.Value, paymentDetail);
}
else
{
paymentDetail = savedAccount.FinancialPaymentDetail;
locationId = paymentDetail.BillingLocationId;
paymentInfo = savedAccount.GetReferencePayment();
UpdatePaymentInfoForSavedAccount(scheduleParameters, paymentInfo, person, rockContext, paymentDetail.BillingLocationId.Value, totalAmount.Value);
}
SaveLocationToFamilyIfNone(person, locationId.Value, rockContext);
string errorMessage;
var schedule = gatewayComponent.AddScheduledPayment(financialGateway, paymentSchedule, paymentInfo, out errorMessage);
if (schedule == null || !string.IsNullOrWhiteSpace(errorMessage))
{
GenerateResponse(HttpStatusCode.InternalServerError, errorMessage ?? "The gateway had a problem and/or did not create a transaction as expected");
}
schedule.TransactionFrequencyValueId = paymentSchedule.TransactionFrequencyValue.Id;
if (person.PrimaryAliasId.HasValue)
{
schedule.AuthorizedPersonAliasId = person.PrimaryAliasId.Value;
}
schedule.FinancialPaymentDetail = paymentDetail;
schedule.FinancialPaymentDetail.CurrencyTypeValueId = paymentInfo.CurrencyTypeValue.Id;
if (paymentInfo.CreditCardTypeValue != null)
{
schedule.FinancialPaymentDetail.CreditCardTypeValueId = paymentInfo.CreditCardTypeValue.Id;
}
foreach (var accountAmount in scheduleParameters.AmountDetails)
{
schedule.ScheduledTransactionDetails.Add(new FinancialScheduledTransactionDetail()
{
Amount = accountAmount.Amount,
AccountId = accountAmount.TargetAccountId
});
}
new FinancialScheduledTransactionService(rockContext).Add(schedule);
rockContext.SaveChanges();
});
}
catch (HttpResponseException exception)
{
return(exception.Response);
}
catch (Exception exception)
{
var response = new HttpResponseMessage(HttpStatusCode.InternalServerError);
response.Content = new StringContent(exception.Message);
return(response);
}
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
// POST: api/ReferenceData public ReferenceData Post([FromBody] ScheduleParameters scheduleParameters) => ReferenceDataRepository.GetReferenceData(scheduleParameters);
