public async Task DeletePosReason(int id)
{
var posReason = await _repository.FindAsync <PosReason>(id);
if (posReason != null)
{
await _repository.DeleteAsync(posReason);
}
}
public async Task <GetAdmSchoolGroupResponse> GetAdmSchoolGroup(int id)
{
var admSchoolGroup = await _repository.FindAsync <AdmSchoolGroup>(id);
var admGlobalOption = await _repository.GetAsync <AdmGlobalOption>(x => true); //should be only one
var result = _autoMapper.Map <GetAdmSchoolGroupResponse>(admSchoolGroup);
result.ShowCEP = admGlobalOption.CEPSchoolOption == CEPSchoolOption.SchoolGroups;
return(result);
}
public async Task <GetReplyMessageResponse> ReplyMessage(int admMessageId)
{
//Create MessageDetailsModel object
GetReplyMessageResponse model = new GetReplyMessageResponse();
//Create a list object of type int
List <int> userIDsList = new List <int>();
//Create a list object of type string
List <string> userNamesList = new List <string>();
//Make call to repo to get the AdmMessageDetail object by ID
var message = await _repository.FindAsync <AdmMessagesDetail>(admMessageId);
//Check to see if the object is not null
if (message != null)
{
//Get the AdmMessageId and store into the request
model.AdmMessageId = message.AdmMessageID;
//Add the AdmUserID to the List of Int (userIDsList)
userIDsList.Add(message.AdmUser.AdmUserID);
//Add the First and Last Name of the Adm User
userNamesList.Add(message.AdmUser.FirstName + " " + message.AdmUser.LastName);
//Checks Message Recipients to ensure it's not null and that there are recipients
if (message.AdmMessage.Recipients != null && message.AdmMessage.Recipients.Any())
{
//Loops through AdmUser object and adds the AdmUserID to the userIDsList
//Also adds the First Name and Last Name to the userNamesList
foreach (var user in message.AdmMessage.Recipients)
{
userIDsList.Add(user.AdmUserID);
userNamesList.Add(user.FirstName + " " + user.LastName);
}
}
}
model.UserIDs = String.Join(",", userIDsList);
model.UserNames = String.Join(", ", userNamesList);
//Ensures the message isn't null and adds the MessageText to the request
if (message != null)
{
model.Message = RemoveHtmlTags(message.MesageText);
}
return(model);
}
public async Task SaveAdmManagementLevels(IEnumerable <AdmManagementLevelSaveModel> requestItems)
{
var existingIds = new List <int>();
foreach (var item in requestItems)
{
//update
if (item.AdmManagementLevelID != 0)
{
existingIds.Add(item.AdmManagementLevelID);
var existingAdmManagementLevel = await _repository.FindAsync <AdmManagementLevel>(item.AdmManagementLevelID);
if (existingAdmManagementLevel != null)
{
existingAdmManagementLevel.Description = item.Description;
existingAdmManagementLevel.ManagementLevelOrder = item.ManagementLevelOrder;
await _repository.UpdateAsync(existingAdmManagementLevel);
}
}
//insert
else
{
var newAdmManagementLevel = _autoMapper.Map <AdmManagementLevel>(item);
await _repository.CreateAsync(newAdmManagementLevel);
}
}
//delete
var deletedItems = await _repository.GetListAsync <AdmManagementLevel>(x => !existingIds.Contains(x.AdmManagementLevelID));
await _repository.DeleteAsync(deletedItems);
}
public async Task <List <int> > SaveAccP2Rates(IEnumerable <AccP2RateSaveModel> requestItems)
{
var idCollection = new List <int>();
foreach (var accP2RateSaveModel in requestItems)
{
if (accP2RateSaveModel.IsBreakfastOnly)
{
accP2RateSaveModel.LUFreeRate = 0;
accP2RateSaveModel.LUReducedRate = 0;
accP2RateSaveModel.LUFullPayRate = 0;
}
var admOptions = await _repository.GetAsync <AdmSitesOption>(x => x.AdmSiteID == accP2RateSaveModel.AdmSiteID);
var accP2Rate = await _repository.FindAsync <AccP2Rates>(accP2RateSaveModel.AccP2RateID) ?? new AccP2Rates();
accP2Rate = _autoMapper.Map(accP2RateSaveModel, accP2Rate);
//audit fields CreatedBy, ModifiedDate etc. should be set in a generic place, not each place we use repo for create/update
if (accP2RateSaveModel.AccP2RateID == 0)
{
accP2Rate.EffectiveDate = DateTime.Parse($"7/1/{admOptions?.BaseYearStart ?? DateTime.Now.Year}");
await _repository.CreateAsync(accP2Rate);
}
else
{
await _repository.UpdateAsync(accP2Rate);
}
idCollection.Add(accP2Rate.AccP2RateID);
}
return(idCollection);
}
public async Task <List <MenCnResultsDetailModel> > GetImportResultsDetails(int menCnResultsHeaderID)
{
var menCnResultsHeader = await _repository.FindAsync <MenCnResultsHeader>(menCnResultsHeaderID);
var menCnResultsDetails = menCnResultsHeader.MenCnResultsDetail.OrderByDescending(x => x.MenCnResultsDetailID);
return(_autoMapper.Map <List <MenCnResultsDetailModel> >(menCnResultsDetails));
}
public async Task <bool> DeleteServingPeriods(int id)
{
if (id == 0)
{
return(false);
}
await _repository.DeleteAsync(await _repository.FindAsync <AdmServingPeriod>(id));
return(true);
}
public async Task <SaveYearEndProcessSetupResponse> SaveYearEndProcessSetup(SaveYearEndProcessSetupRequest request)
{
var newOptions = new AdmYearEndProcessOptions();
DateTime today = _repository.GetSchoolNow(request.AdmUserId);
if (request.DefaultTempStatusExpDate == null)
{
request.DefaultTempStatusExpDate = today.ToUsDateString();
}
var options =
await _repository.GetListAsync <AdmYearEndProcessOptions>(o => o.OptionsForTheYear == request.OptionsForTheYear);
if (options.Any())
{
newOptions = await _repository.FindAsync <AdmYearEndProcessOptions>(request.OptionsForTheYear);
_autoMapper.Map(request, newOptions);
InitNewOption(request, newOptions, today);
newOptions = _repository.Update(newOptions);
}
else
{
_autoMapper.Map(request, newOptions);
InitNewOption(request, newOptions, today);
newOptions = _repository.Create <AdmYearEndProcessOptions>(newOptions);
}
await UpdateSchoolDates(request.DefaultStartDate, request.DefaultEndDate, request.DefaultTempStatusExpDate);
var farOptions = (await _repository.GetListAsync <FarOption>()).FirstOrDefault();
if (farOptions != null)
{
farOptions.StartingAppNumber = request.StartingAppNumber;
farOptions = await _repository.UpdateAsync(farOptions);
}
return(_autoMapper.Map <SaveYearEndProcessSetupResponse>(request));
}
private async Task SaveCustomDisclosures(ICollection <FroCustomizationSaveModel> requestCustomizations)
{
// save the disclaimer actives
foreach (var saveModel in requestCustomizations)
{
var custom = await _repository.FindAsync <FroCustomization>(saveModel.FroCustomizationID);
// should technically always find this, but just in case
if (custom != null)
{
// only update if there was a change
if (custom.IsActive != saveModel.IsActive)
{
custom.IsActive = saveModel.IsActive;
await _repository.UpdateAsync(custom);
}
}
}
}
public async Task <PutIntegrationMapsResponse> SaveIntegrationMap(PutIntegrationMapsRequest request)
{
var map = request.AdmIntegrationMapID != 0
? await _repository.FindAsync <AdmIntegrationMap>(request.AdmIntegrationMapID)
: new AdmIntegrationMap();
if (map == null)
{
Debug.WriteLine($"Integration map not found in database. Id: {request.AdmIntegrationMapID}");
throw new ApplicationException($"{request.AdmIntegrationMapID} integration map not found");
}
var response = new PutIntegrationMapsResponse();
//automapper can handle all this stuff, however without proper testing I will just follow the old logic
MapKnownFields(map, request);
if (request.DeletePreviewFile && map.PreviewFile != null)
{
_repository.MarkForDeletion(map.PreviewFile);
}
await ProcessTriageFile(map, request);
if (request.Columns != null && request.Columns.Any())
{
ProcessColumns(map, request.Columns, request.UseHeaderDetail);
}
if (map.AdmIntegrationMapID == 0)
{
await _repository.CreateAsync(map);
}
else
{
await _repository.UpdateAsync(map);
}
response.IntegrationMapId = map.AdmIntegrationMapID;
return(response);
}
public async Task <GetIntegrationJobDetailsResponse> GetIntegrationJobDetails(GetIntegrationJobDetailsRequest request)
{
GetIntegrationJobDetailsResponse model;
AdmIntegrationJob job = null;
switch (request.JobId)
{
case 0: // find first
var view = await _repository.GetAsync <AppView>(v => v.AppObjectID == "Integration" && v.ViewName == "Index");
if (view != null)
{
var pref = (await _repository.GetListAsync <AppViewsAdmUsersPreference>(p => p.AdmUserID == request.CurrentAdmUserId &&
p.AppViewID == view.AppViewID))
.FirstOrDefault();
if (pref?.LastViewedID != null)
{
request.JobId = pref.LastViewedID.Value;
}
}
if (request.JobId != 0)
{
job = (await _repository.GetListAsync <AdmIntegrationJob>(j => j.AdmIntegrationJobID == request.JobId && !j.IsDeleted))
.FirstOrDefault();
}
if (job == null)
{
job = (await _repository.GetListAsync <AdmIntegrationJob>())
.OrderBy(o => o.Name)
.FirstOrDefault(o => !o.IsDeleted);
}
break;
case -1: //new one
break;
default:
job = await _repository.FindAsync <AdmIntegrationJob>(request.JobId);
await SaveUserLastViewed(request.JobId, request.CurrentAdmUserId);
break;
}
if (job == null)
{
model = new GetIntegrationJobDetailsResponse()
{
JobName = "",
JobDescription = "",
TaskModel = new AdmScheduledTaskItem(),
IsImport = request.IsImport.HasValue && request.IsImport.Value,
MapType = (int)GetMapType(request.MapTypeName),
GradeSchoolChangeThreshhold = 10,
CNIPsVendorNumber = "",
CNIPsCDSNumber = "",
CNIPsLicenseNumber = "",
CNIPsSponsor = "",
CNIPsID = ""
};
}
else
{
model = _autoMapper.Map <GetIntegrationJobDetailsResponse>(job);
model.JobName = job.Name;
model.JobDescription = job.Description;
model.IsImport = job.AdmIntegrationMap.IsImport;
model.JobCriteriaColumns = BuildJobCriteriaColumns(job);
// krp 2do - does this work? without recalling the db to populate the AdmIntegrationMap
model.MapType = job.AdmIntegrationMap.MapType; // GetImportType(job.AdmIntegrationMapID)
model = await UpdateModelWithCniPs(model);
model.TaskModel = new AdmScheduledTaskItem();
var sched = await _repository.GetAsync <AdmScheduledTask>(t => t.AdmIntegrationJobID == job.AdmIntegrationJobID);
if (sched != null)
{
model.TaskModel = _autoMapper.Map <AdmScheduledTaskItem>(sched);
if (sched.StartTime.HasValue)
{
model.TaskModel.StartTime =
new DateTime(((TimeSpan)sched.StartTime).Ticks);
}
}
}
var integrationMaps =
await _repository.GetListAsync <AdmIntegrationMap>(q =>
q.MapType == model.MapType && q.IsImport == model.IsImport);
model.Maps = _autoMapper.Map <Collection <IntegrationMapItem> >(integrationMaps);
if (model.Maps.Count == 0 && model.AdmIntegrationMapID == 0 &&
(model.MapType == (int)IntegrationMapType.Gordon_Foods_Order_Export) ||
(model.MapType == (int)IntegrationMapType.CNIPs))
{
var map = await GetNewMap(model.MapType);
model.Maps.Add(_autoMapper.Map <IntegrationMapItem>(map));
}
return(model);
}
public async Task SaveSchoolsInformation(PutSchoolsInformationRequest model)
{
var validations = await ValidateSchoolData(model);
if (!validations.Any())
{
if (model.AdmSiteId != 0)
{
var site = await _repo.FindAsync <AdmSite>(model.AdmSiteId);
site.SiteID = model.SiteId;
site.SiteDescription = model.SiteDescription;
site.AdmManagementLevelID = model.AdmManagementLevelId;
site.ParentAdmSiteID = model.ParentAdmSiteId;
site.InvSiteTypeID = model.InvSiteTypeId;
site.State = model.State;
site.IsDistrict = model.IsDistrict;
site.IsActive = model.IsActive;
site.MenAgeGroupID = model.MenAgeGroupID;
site.Address1 = model.Address1;
site.Address2 = model.Address2;
site.City = model.City;
site.ZipCode = model.ZipCode;
site.SchoolPhoneNumber = model.SchoolPhoneNumber;
site.PrincipalPhoneNumber = model.ManagerPhoneNumber;
site.PrincipalName = model.ManagerName;
site.PrincipalEmail = model.ManagerEmail;
if (string.IsNullOrWhiteSpace(model.AccLockoutDate))
{
DateTime schoolStartDate = model.Calendar.SchoolStartDate.ParseUsDate() ?? DateTime.MinValue;
site.AccLockoutDate = schoolStartDate;
}
else
{
site.AccLockoutDate = model.AccLockoutDate.ParseUsDate();
}
// Create or Update the Site Options
if (site.AdmSitesOption == null)
{
var options = new AdmSitesOption
{
AdmSiteID = model.AdmSiteId,
SchoolStartDate = model.Calendar.SchoolStartDate.ParseUsDate(),
IsYearRoundSchool = model.Calendar.IsYearRoundSchool
};
site.AdmSitesOption = options;
}
else
{
site.AdmSitesOption.SchoolStartDate = model.Calendar.SchoolStartDate.ParseUsDate();
site.AdmSitesOption.IsYearRoundSchool = model.Calendar.IsYearRoundSchool;
if (model.Calendar.IsYearRoundSchool == false)
{
site.AdmSitesOption.SchoolAltStartDate = null;
site.AdmSitesOption.SchoolTempStatusExpDate = null;
site.AdmSitesOption.SchoolStartDate = model.Calendar.SchoolStartDate.ParseUsDate();
}
}
//PMM 9/21/15
site.AdmSitesOption.IsClaimChildSitesSeparately = model.SiteOptions.IsClaimChildSitesSeparately;
site.AdmSitesOption.IsRefundAllowed = model.SiteOptions.IsRefundAllowed;
site.AdmSitesOption.SiteAttendanceFactor = model.SiteOptions.SiteAttendanceFactor;
site.AdmSitesOption.IsCEP = model.SiteOptions.IsCEP;
site.AdmSitesOption.IsDontInactivateMissingStudent = model.SiteOptions.IsDontInactivateMissingStudent;
site.AdmSitesOption.IsSevereNeed = model.SiteOptions.IsSevereNeed;
//AMH SLN-3147 Provision 2 settings
site.AdmSitesOption.IsProvisionSite = model.SiteOptions.IsProvisionSite;
site.AdmSitesOption.BaseYearStart = model.SiteOptions.BaseYearStart;
site.AdmSitesOption.BaseYearEnrollment = model.SiteOptions.BaseYearEnrollment;
site.AdmSitesOption.BaseYearFree = model.SiteOptions.BaseYearFree;
site.AdmSitesOption.BaseYearReduced = model.SiteOptions.BaseYearReduced;
//time zone
await SaveCentralOfficeTimeZone(model.COTimeZoneName);
site.AdmSitesOption.TimeZoneName = model.TimeZoneName;
//AMH S-03093 if CW, create InvVendor for the CW
if (site.AdmSitesOption.IsWarehouse)
{
InvVendors cwVendor = await _repo.GetAsync <InvVendors>(v => v.AdmSiteID == model.AdmSiteId);
cwVendor.Name = site.SiteDescription;
cwVendor.Active = site.IsActive;
cwVendor.VendorNumber = site.SiteID;
cwVendor.Address = site.Address1;
cwVendor.Address2 = site.Address2;
cwVendor.City = site.City;
cwVendor.State = site.State;
cwVendor.ZipCode = site.ZipCode;
cwVendor.PhoneNumber = site.PrincipalPhoneNumber;
cwVendor.Email = site.PrincipalEmail;
await _repo.UpdateAsync <InvVendors>(cwVendor);
}
// Create or Update the Site PIN Configuration
AdmSitesPINConfiguration pinConfig = site.AdmSitesPINConfiguration;
if (pinConfig == null)
{
pinConfig = new AdmSitesPINConfiguration {
AdmSiteID = model.AdmSiteId
};
}
pinConfig.PINLength = model.PinConfiguration.PINLength;
pinConfig.PadPINWithZeros = model.PinConfiguration.PadPINWithZeros;
pinConfig.StudentRandomlyGeneratePIN = model.PinConfiguration.StudentRandomlyGeneratePIN;
pinConfig.StudentIsLeftOfID = model.PinConfiguration.StudentIsLeftOfId;
pinConfig.StudentLeftOfID = model.PinConfiguration.StudentLeftOfId;
pinConfig.StudentRightOfID = model.PinConfiguration.StudentRightOfId;
pinConfig.StudentAppendToPIN = model.PinConfiguration.StudentAppendToPIN;
pinConfig.StudentPreventLeadingZeros = model.PinConfiguration.StudentPreventLeadingZeros;
pinConfig.StudentAppendPosition = model.PinConfiguration.StudentAppendPosition;
pinConfig.StudentAppendText = model.PinConfiguration.StudentAppendText;
pinConfig.UseAdultSettings = model.PinConfiguration.UseAdultSettings;
if (model.PinConfiguration.UseAdultSettings)
{
pinConfig.AdultRandomlyGeneratePIN = model.PinConfiguration.StudentRandomlyGeneratePIN;
pinConfig.AdultIsLeftOfID = model.PinConfiguration.StudentIsLeftOfId;
pinConfig.AdultLeftOfID = model.PinConfiguration.StudentLeftOfId;
pinConfig.AdultRightOfID = model.PinConfiguration.StudentRightOfId;
pinConfig.AdultAppendToPIN = model.PinConfiguration.StudentAppendToPIN;
pinConfig.AdultPreventLeadingZeros = model.PinConfiguration.StudentPreventLeadingZeros;
pinConfig.AdultAppendPosition = model.PinConfiguration.StudentAppendPosition;
pinConfig.AdultAppendText = model.PinConfiguration.StudentAppendText;
}
else
{
pinConfig.AdultRandomlyGeneratePIN = model.PinConfiguration.AdultRandomlyGeneratePIN;
pinConfig.AdultIsLeftOfID = model.PinConfiguration.AdultIsLeftOfId;
pinConfig.AdultLeftOfID = model.PinConfiguration.AdultLeftOfId;
pinConfig.AdultRightOfID = model.PinConfiguration.AdultRightOfId;
pinConfig.AdultAppendToPIN = model.PinConfiguration.AdultAppendToPIN;
pinConfig.AdultPreventLeadingZeros = model.PinConfiguration.AdultPreventLeadingZeros;
pinConfig.AdultAppendPosition = model.PinConfiguration.AdultAppendPosition;
pinConfig.AdultAppendText = model.PinConfiguration.AdultAppendText;
}
site.AdmSitesPINConfiguration = pinConfig;
if (model.Terminals != null) //terminals collection deserialized in the validate method
{
foreach (var term in model.Terminals)
{
if (term.IsDeleted)
{
_repo.MarkForDeletion(term);
}
else
{
PosTerminal terminal;
if (term.PosTerminalId == 0)
{
terminal = new PosTerminal();
site.PosTerminals.Add(terminal);
}
else
{
terminal = site.PosTerminals.FirstOrDefault(t => t.PosTerminalID == term.PosTerminalId);
}
if (terminal != null)
{
terminal.MachineName = term.MachineName.Trim();
terminal.TerminalNumber = term.TerminalNumber;
terminal.IsAutoSale = term.IsAutoSale;
terminal.IsActive = term.IsActive;
}
}
}
}
site.AdmSitesServePOS.Clear();
model.ServingSites.ForEach(s => site.AdmSitesServePOS.Add(new AdmSitesServePOS()
{
AdmSiteID = s.AdmSiteId, OtherAdmSiteID = s.OtherAdmSiteId
}));
// set the customer number
site.CustomerNumber = model.CustomerNumber;
await _repo.UpdateAsync <AdmSite>(site);
}
}
if (model.SiteOptions.IsCEP)
{
var admGlobalOptions = (await _repo.GetListAsync <AdmGlobalOption>()).FirstOrDefault();
var claimOption = -1;
if (admGlobalOptions != null && (CEPSchoolOption.District == admGlobalOptions.CEPSchoolOption && model.IsDistrict))
{
claimOption = 0;
}
else if (admGlobalOptions != null && ((CEPSchoolOption.Schools == admGlobalOptions.CEPSchoolOption || CEPSchoolOption.SchoolGroups == admGlobalOptions.CEPSchoolOption) && model.IsDistrict == false))
{
claimOption = 1;
}
if (claimOption != -1)
{
await PopulateAccCEPRates(claimOption, model.AdmSiteId, 0);
}
}
else if (model.SiteOptions.IsProvisionSite)
{
var userInfo = await _repo.FindAsync <AdmUser>(model.AdmUserId);
var createdBy = userInfo.FirstName + " " + userInfo.LastName;
var exists = (await _repo.GetListAsync <AccP2Rates>(w => w.AdmSiteID == model.AdmSiteId)).Any();
if (exists == false)
{
var baseYear = "7/1/" + model.SiteOptions.BaseYearStart;
AccP2Rates claimPct = new AccP2Rates
{
AdmSiteID = model.AdmSiteId,
IsBreakfastOnly = false,
BRFreeRate = 0,
BRReducedRate = 0,
BRFullPayRate = 0,
LUFreeRate = 0,
LUReducedRate = 0,
LUFullPayRate = 0,
EffectiveDate = DateTime.Parse(baseYear),
CreatedDateTime = DateTime.Now,
CreatedBy = createdBy,
LastModifiedDateTime = DateTime.Now,
LastModifiedBy = createdBy
};
await _repo.CreateAsync <AccP2Rates>(claimPct);
}
}
}
public async Task <int> SaveFeedingFigure(PostFeedingFiguresRequest request)
{
if (request.FeedingNumber != null)
{
request.FeedingNumber = Convert.ToInt32(request.FeedingNumber);
}
var figures = await _repo.FindAsync <AdmSitesFeedingFigure>(request.AdmSiteId);
if (figures == null)
{
//insert
AdmSitesFeedingFigure newFigures = new AdmSitesFeedingFigure {
AdmSiteID = request.AdmSiteId
};
switch (request.FeedingName)
{
case "Breakfast":
newFigures.Breakfast = request.FeedingNumber;
break;
case "Lunch":
newFigures.Lunch = request.FeedingNumber;
break;
case "Snack":
newFigures.Snack = request.FeedingNumber;
break;
case "Supper":
newFigures.Supper = request.FeedingNumber;
break;
}
await _repo.CreateAsync(newFigures);
return(newFigures.AdmSiteID);
}
else
{
//update
switch (request.FeedingName)
{
case "Breakfast":
figures.Breakfast = request.FeedingNumber;
break;
case "Lunch":
figures.Lunch = request.FeedingNumber;
break;
case "Snack":
figures.Snack = request.FeedingNumber;
break;
case "Supper":
figures.Supper = request.FeedingNumber;
break;
}
await _repo.UpdateAsync(figures);
return(figures.AdmSiteID);
}
}
