public async Task <int> Create(CreateSiteTypeRequest request)
{
var invSiteType = _autoMapper.Map <InvSiteType>(request);
await _repo.CreateAsync(invSiteType);
return(invSiteType.InvSiteTypeID);
}
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 <bool> SendMessageUpdate(PostMessageUpdateRequest request)
{
string message = request.Message;
int admUserId = request.AdmUserId;
int admSiteId = request.AdmSiteId;
AdmMessage admMessage = _autoMapper.Map <AdmMessage>(request);
admMessage.MessageDate = _repository.GetSchoolNow(admSiteId);
foreach (var id in request.UserIDs)
{
AdmUser admUser = await _repository.GetAsync <AdmUser>(u => u.AdmUserID == id);
admMessage.Recipients.Add(admUser);
}
bool isForwarded = request.ActionType.Equals("forwarded");
admMessage.AdmMessagesDetails.Add(new AdmMessagesDetail
{
AdmMessageID = admMessage.AdmMessageID,
SentByAdmUserID = admUserId,
MesageText = message.Trim(),
MessageDate = _repository.GetSchoolNow(admSiteId),
IsForwarded = isForwarded
});
await _repository.CreateAsync <AdmMessage>(admMessage);
return(true);
}
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);
}
private async Task PopulateAccCEPRates(int admSchoolGroupID)
{
var createPct = await _repository.GetAsync <AccCEPRates>(x => x.AdmSchoolGroupID == admSchoolGroupID);
if (createPct == null)
{
createPct = new AccCEPRates
{
AdmSchoolGroupID = admSchoolGroupID,
CEPFreeRate = 0,
CEPFullPayRate = 0
};
await _repository.CreateAsync(createPct);
}
_repository.SaveChanges();
}
public async Task <int> SavePosReason(string reason)
{
var posReason = await _repository.GetAsync <PosReason>(x => x.Reason == reason.Trim().ToLower());
if (posReason != null)
{
posReason.IsDeleted = false;
await _repository.UpdateAsync(posReason);
}
else
{
posReason = await _repository.CreateAsync(new PosReason
{
Reason = reason
});
}
return(posReason.PosReasonID);
}
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 <SaveGradeSitePromotionsResponse> SaveGradeSitePromotions(SaveGradeSitePromotionsRequest request)
{
var toSave = new List <AdmGradeSitePromotion>();
var promotions = _repository.GetQueryable <AdmGradeSitePromotion>().ToList();
await _repository.DeleteAsync <AdmGradeSitePromotion>(promotions);
var modelsList = request.Promotions.Where(l => l.PromotingPosGradeID.HasValue && l.PromotingPosGradeID != 0);
foreach (var model in modelsList)
{
DateTime today = _repository.GetSchoolNow(model.AdmSiteID);
var site = promotions.FirstOrDefault(s => s.AdmSiteID == model.AdmSiteID);
if (site == null)
{
site = new AdmGradeSitePromotion()
{
AdmSiteID = model.AdmSiteID,
PosGradeID = model.PromotingPosGradeID ?? 0,
LastUpdatedBy = request.AdmSiteId,
LastUpdatedDate = today
};
}
if (site.PosGradeID != model.PromotingPosGradeID || site.PromoteToAdmSiteID != model.PromoteToAdmSiteID)
{
site.LastUpdatedBy = request.AdmSiteId;
site.LastUpdatedDate = today;
}
site.PosGradeID = model.PromotingPosGradeID ?? 0;
site.PromoteToAdmSiteID = model.PromoteToAdmSiteID;
toSave.Add(site);
}
var createdPromotions = await _repository.CreateAsync <AdmGradeSitePromotion>(toSave);
return(new SaveGradeSitePromotionsResponse
{
Items = _autoMapper.Map <ICollection <SavedSitePromotionModel> >(createdPromotions)
});
}
public async Task <PostJobDetailsResponse> SaveJobDetails(PostJobDetailsRequest request)
{
DateTime today = _repository.GetSchoolNow(request.admSiteId);
if (!string.IsNullOrEmpty(request.FileLocation))
{
request.FileLocation = request.FileLocation.Trim();
}
if (!string.IsNullOrEmpty(request.FileFtpUserName))
{
request.FileFtpUserName = request.FileFtpUserName.Trim();
}
if (!string.IsNullOrEmpty(request.FileFtpPassword))
{
request.FileFtpPassword = request.FileFtpPassword.Trim();
}
if (!request.IsImport &&
((request.MapType == IntegrationMapType.Gordon_Foods_Order_Export) ||
(request.MapType == IntegrationMapType.CNIPs)) &&
request.AdmIntegrationMapID == 0)
{
var map = await GetNewMap((int)request.MapType);
request.AdmIntegrationMapID = map.AdmIntegrationMapID;
}
var dbJob = request.AdmIntegrationJobID == 0 ? new AdmIntegrationJob() :
await _repository.FindAsync <AdmIntegrationJob>(request.AdmIntegrationJobID);
dbJob.AdmIntegrationJobID = request.AdmIntegrationJobID;
dbJob.AdmIntegrationMapID = request.AdmIntegrationMapID;
dbJob.Name = request.JobName;
dbJob.Description = request.JobDescription;
dbJob.IsInactivateObjectsNotInSource = request.IsInactivateObjectsNotInSource;
dbJob.IsThreshholdNewRecords = request.IsThreshholdNewRecords;
dbJob.ThreshholdNewRecordsPercent = request.ThreshholdNewRecordsPercent;
dbJob.IsThreshholdErrors = request.IsThreshholdErrors;
dbJob.ThreshholdErrorsPercent = request.ThreshholdErrorsPercent;
dbJob.IsUpdateOnly = request.IsUpdateOnly;
dbJob.IsDCImport = request.IsDCImport;
dbJob.IsAppImport = request.IsAppImport;
dbJob.IsAutomated = request.IsAutomated;
dbJob.FileSourceType = request.FileSourceType;
dbJob.FileLocation = request.FileLocation;
dbJob.FileFtpUserName = request.FileFtpUserName;
dbJob.FileFtpPassword = request.FileFtpPassword;
dbJob.IsOverrideGradeSchoolChangeThreshhold = request.IsOverrideGradeSchoolChangeThreshhold; //PMM 5/3/16
// The sledgehammer method:
// we could traverse all the Criteria columns and values, updating existing ones
// adding new ones and deleting ones no longer used and we'd also have to traverse
// all the column values within each column, adding new values and removing values.
// but that's a lot of complicated code. We don't save exports that often so
// simply deleting what's already in the DB and re-adding everything is
// soon much simpler. the only cost is the delete/insert actions on a very small table
// ....and we're done. so...........
//delete all criteria columns and values.
dbJob.AdmIntegrationJobCriteriaColumns.ToList().ForEach(e =>
{
e.AdmIntegrationJobCriteriaColumnValues.ToList().ForEach(e2 => _repository.MarkForDeletion(e2));
_repository.MarkForDeletion(e);
});
//add Criteria Columns and Values from the request
if (request.JobCriteriaColumns != null && request.JobCriteriaColumns.Any())
{
foreach (JobCriteraColumn col in request.JobCriteriaColumns)
{
//create the column, add the values, then add column to the DBJob
bool isIdComparison = col.ColumnName == "isActive"; //hard coding this for most jobs so it compares the value.
var dbCol = new AdmIntegrationJobCriteriaColumn()
{
ColumnName = col.ColumnName,
IsIDComparison = isIdComparison
};
foreach (JobCriteriaColumnValue val in col.ColumnCriteriaValues)
{
dbCol.AdmIntegrationJobCriteriaColumnValues.Add(
new AdmIntegrationJobCriteriaColumnValue()
{
CriteriaID = val.Id,
CriteriaValue = val.Value ?? ""
}
);
}
dbJob.AdmIntegrationJobCriteriaColumns.Add(dbCol);
}
}
if (dbJob.IsAutomated)
{
AdmScheduledTask task;
if (dbJob.AdmScheduledTasks.Count == 0)
{
task = new AdmScheduledTask {
CreatedDate = today
};
dbJob.AdmScheduledTasks.Add(task);
}
else
{
task = dbJob.AdmScheduledTasks.First();
}
task.AdmScheduledTaskName = dbJob.Name;
task.AdmScheduledTaskType = ScheduledTaskType.IntegrationJob;
if (_repository.CurrentAdmUserId != null)
{
task.AdmUserID = (int)_repository.CurrentAdmUserId;
}
task.Frequency = request.TaskModel.Frequency;
task.StartDate = request.TaskModel.StartDate;
task.RunOnStartup = request.TaskModel.RunOnStartup;
task.IsDeleted = false;
if (request.TaskModel.StartTime != null)
{
task.StartTime = request.TaskModel.StartTime;
}
}
else
{
if (dbJob.AdmScheduledTasks.Count != 0)
{
dbJob.AdmScheduledTasks.First().IsDeleted = true;
}
}
var userInfo = await _repository.FindAsync <AdmUser>(request.AdmUserID);
var createdBy = userInfo.FirstName + " " + userInfo.LastName;
if (dbJob.AdmIntegrationJobID == 0)
{
dbJob.CreatedBy = createdBy;
dbJob.CreatedDateTime = DateTime.Now;
}
else
{
dbJob.LastModifiedBy = createdBy;
dbJob.LastModifiedDateTime = DateTime.Now;
}
dbJob = dbJob.AdmIntegrationJobID == 0 ?
await _repository.CreateAsync(dbJob) :
await _repository.UpdateAsync(dbJob);
await SaveUserLastViewed(dbJob.AdmIntegrationJobID);
return(_autoMapper.Map <PostJobDetailsResponse>(dbJob));
}
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 <PutServingPeriodsResponse> SaveServingPeriods(PutServingPeriodsRequest request)
{
if (request.Periods == null)
{
return new PutServingPeriodsResponse {
Success = false, Error = string.Empty
}
}
;
request.Periods.Where(p => p.Description != null).ToList().ForEach(x => x.Description = x.Description.Trim());
request.Periods.Where(p => p.Abbreviation != null).ToList().ForEach(x => x.Abbreviation = x.Abbreviation.Trim());
if (request.Periods.Any(p => string.IsNullOrEmpty(p.Description)))
{
return(new PutServingPeriodsResponse
{
Success = false,
Error = "Description is required. Please check the data and try again."
});
}
if (request.Periods.Any(p => string.IsNullOrEmpty(p.Abbreviation)))
{
return(new PutServingPeriodsResponse
{
Success = false,
Error = "Abbreviation is required. Please check the data and try again."
});
}
//validate duplicates
var dupDescriptions = request.Periods.GroupBy(g => g.Description)
.Where(c => c.Count() > 1)
.Select(g => g.Key)
.ToList();
if (dupDescriptions.Count > 0)
{
StringBuilder error = new StringBuilder();
foreach (string desc in dupDescriptions)
{
if (error.Length > 0)
{
error.Append(", ");
}
error.Append(desc);
}
return(new PutServingPeriodsResponse
{
Success = false,
Error =
$"Duplicate Description{(dupDescriptions.Count == 1 ? string.Empty : "s")} detected: {error}. Please check the data and try again."
});
}
dupDescriptions = request.Periods.GroupBy(g => g.Abbreviation)
.Where(c => c.Count() > 1)
.Select(g => g.Key)
.ToList();
if (dupDescriptions.Count > 0)
{
StringBuilder error = new StringBuilder();
foreach (string desc in dupDescriptions)
{
if (error.Length > 0)
{
error.Append(", ");
}
error.AppendLine(desc);
}
return(new PutServingPeriodsResponse
{
Success = false,
Error =
$"Duplicate Abbreviation{(dupDescriptions.Count == 1 ? string.Empty : "s")} detected: {error}. Please check the data and try again."
});
}
var dataPeriods = await _repository.GetListAsync <AdmServingPeriod>();
// have to re-sync after deletions
int position = 1;
foreach (ServingPeriod pos in request.Periods)
{
pos.DisplayOrder = position++;
}
foreach (var p in request.Periods)
{
var editPeriod = p.AdmServingPeriodId == 0 ? new AdmServingPeriod() : dataPeriods.First(x => x.AdmServingPeriodID == p.AdmServingPeriodId);
editPeriod.Description = p.Description;
editPeriod.DisplayOrder = p.DisplayOrder;
editPeriod.PeriodType = p.PeriodType;
editPeriod.ConversionFactor = p.ConversionFactor;
editPeriod.Abbreviation = p.Abbreviation;
editPeriod.MenuAnalysisType = p.MenuAnalysisType;
//delete periods
for (int i = editPeriod.AdmSitesServingPeriods.Count - 1; i >= 0; i--)
{
AdmSitesServingPeriod checkPeriod = editPeriod.AdmSitesServingPeriods.ElementAt(i);
if (!p.AssignedSiteIDs.Contains(checkPeriod.AdmSiteID))
{
editPeriod.AdmSitesServingPeriods.Remove(checkPeriod);
}
}
//add new periods
foreach (var siteId in p.AssignedSiteIDs)
{
if (editPeriod.AdmSitesServingPeriods.FirstOrDefault(x => x.AdmSiteID == siteId) == null)
{
editPeriod.AdmSitesServingPeriods.Add(new AdmSitesServingPeriod {
AdmServingPeriodID = editPeriod.AdmServingPeriodID, AdmSiteID = siteId
});
}
}
if (p.AdmServingPeriodId == 0)
{
await _repository.CreateAsync(editPeriod);
}
}
await _repository.UpdateAsync <AdmServingPeriod>(dataPeriods);
return(new PutServingPeriodsResponse {
Success = true, Periods = request.Periods
});
}
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);
}
}
