public ActionResult CreateOffer([FromBody] PostEmailOfferDTO EmailOfferRelatedDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (EmailOfferRelatedDTO.ProcedureIds.Count > 0)
{
foreach (int id in EmailOfferRelatedDTO.ProcedureIds)
{
EmailOffer emailOfferRelated = new EmailOffer()
{
GUId = EmailOfferRelatedDTO.GUId,
ProcedureId = id,
//CoursePackageIds = EmailOfferRelatedDTO.CoursePackageIds,
//AlternativeCousrsePackages = EmailOfferRelatedDTO.AlternativeCousrsePackages,
CreatedDate = DateTime.UtcNow,
CreatedBy = EmailOfferRelatedDTO.CreatedBy,
};
_choiceRepository.Add <EmailOffer>(emailOfferRelated);
var Procedure = _choiceRepository.DbContext.Procedure.Where(x => x.ProcedureId == id).FirstOrDefault();
if (Procedure != null)
{
Procedure.UsedInEmailOffer = true;
_choiceRepository.Attach(Procedure);
}
}
}
if (EmailOfferRelatedDTO.CoursePackageIds.Count > 0)
{
for (int i = 0; i < EmailOfferRelatedDTO.CoursePackageIds.Count; i++)
{
EmailOfferCoursePackages emailOfferPackages = new EmailOfferCoursePackages()
{
GUId = EmailOfferRelatedDTO.GUId,
CoursePackageId = EmailOfferRelatedDTO.CoursePackageIds[i],
AlternativeCousrsePackageName = EmailOfferRelatedDTO.AlterNativeCoursePackageNames[i],
//CoursePackageIds = EmailOfferRelatedDTO.CoursePackageIds,
//AlternativeCousrsePackages = EmailOfferRelatedDTO.AlternativeCousrsePackages,
CreatedDate = DateTime.UtcNow,
CreatedBy = EmailOfferRelatedDTO.CreatedBy,
};
_choiceRepository.Add <EmailOfferCoursePackages>(emailOfferPackages);
}
}
_choiceRepository.Complete();
return(CreatedAtRoute("EmailOfferRelatedByGUId", new { EmailOfferRelatedDTO.GUId }, EmailOfferRelatedDTO));
}
public async Task <ObjectResult <ChoiceResponse> > Create(int quizId, int questionId, ChoiceCreateRequest request)
{
var question = await _questionRepository.GetQuestion(quizId, questionId);
if (question == null)
{
return(new ObjectResult <ChoiceResponse> {
Errors = new[] { "Didn't find the question" }
});
}
var choice = _mapper.Map <Choice>(request);
if (choice != null)
{
choice.QuestionId = question.Id;
_choiceRepository.Add(choice);
}
if (await _choiceRepository.SaveChangesAsync())
{
_cache.Set($"Choice {choice.Id}", choice);
return(new ObjectResult <ChoiceResponse> {
Object = _mapper.Map <ChoiceResponse>(choice), Found = true, Success = true
});
}
return(new ObjectResult <ChoiceResponse> {
Found = true, Errors = new[] { "Action didn't affect any rows" }
});
}
public async Task <IChoiceModel> CreateAsync(IChoiceModel choice)
{
choice.ChoiceID = Guid.NewGuid();
choice.DateCreated = DateTime.Now;
choice.DateUpdated = DateTime.Now;
_choiceRepository.Add(choice);
await _choiceRepository.SaveAsync();
return(choice);
}
public IActionResult AddQuestion(QuestionViewModel questionViewModel)
{
Exam exam = examRepository.Get(questionViewModel.ExamId);
if (ModelState.IsValid)
{
Question qusetion = new Question
{
Text = questionViewModel.Text
};
questionRepository.Add(qusetion);
ExamQuestion examQuestion = new ExamQuestion
{
ExamId = questionViewModel.ExamId,
QuestionId = qusetion.Id,
Exam = exam,
Question = qusetion
};
for (int i = 0; i < 4; i++)
{
Choice choice = questionViewModel.Choices[i];
choiceRepository.Add(choice);
QuestionChoice questionChoice = new QuestionChoice
{
Question = qusetion,
Choice = choice,
ChoiceId = choice.Id,
QuestionId = qusetion.Id,
};
questionChoiceRepository.Add(questionChoice);
}
examQuestionRepository.Add(examQuestion);
return(RedirectToAction("Index", new { examId = questionViewModel.ExamId }));
}
return(View());
}
public ActionResult <PartnerCoursePackageDTO> UpdateCoursePackages(int coursePackageId, [FromBody] PutCoursePackageDTO putCoursePackageDTO)
{
var coursePackageEntryInDb = _choiceRepository.GetById <CoursePackage>(x => x.CoursePackageId == coursePackageId);
coursePackageEntryInDb.CoursePackageName = putCoursePackageDTO.CoursePackageName;
coursePackageEntryInDb.CoursePackageNameEN = putCoursePackageDTO.CoursePackageNameEN;
coursePackageEntryInDb.CreatedBy = putCoursePackageDTO.CreatedBy;
coursePackageEntryInDb.CreatedDate = putCoursePackageDTO.CreatedDate;
coursePackageEntryInDb.Offered = putCoursePackageDTO.Offered;
coursePackageEntryInDb.LastModified = putCoursePackageDTO.LastModified;
coursePackageEntryInDb.LastModifiedBy = putCoursePackageDTO.LastModifiedBy;
coursePackageEntryInDb.Price = putCoursePackageDTO.Price;
var allPackageIncludedItems = _choiceRepository.GetAll <PackageIncludedItem>(x => x.CoursePackageId == coursePackageEntryInDb.CoursePackageId);
// First remove all
foreach (var packageIncludeItem in allPackageIncludedItems)
{
_choiceRepository.Remove <PackageIncludedItem>(packageIncludeItem);
}
foreach (var packageIncludedItemDTO in putCoursePackageDTO.PackageIncludedItemDTOs)
{
PackageIncludedItem packageIncludedItem = new PackageIncludedItem();
packageIncludedItem.CoursePackageId = packageIncludedItemDTO.CoursePackageId;
packageIncludedItem.CreatedBy = packageIncludedItemDTO.CreatedBy;
packageIncludedItem.CreatedDate = packageIncludedItemDTO.CreatedDate;
packageIncludedItem.DK = packageIncludedItemDTO.DK;
//packageIncludedItem.Included = packageIncludedItemDTO.Included;
packageIncludedItem.LastModified = packageIncludedItemDTO.LastModified;
packageIncludedItem.LastModifiedBy = packageIncludedItemDTO.LastModifiedBy;
packageIncludedItem.SortingOrder = packageIncludedItemDTO.SortingOrder;
packageIncludedItem.UK = packageIncludedItemDTO.UK;
_choiceRepository.Add <PackageIncludedItem>(packageIncludedItem);
}
_choiceRepository.Complete();
return(null);
}
public ActionResult <PartnerCoursePackageDTO> UpdatePartnerCoursePackages(int partnerCoursePackageId, [FromBody] PutPartnerCoursePackageDTO putPartnerCoursePackageDTO)
{
var partnerCoursePackageEntryInDb = _choiceRepository.GetById <PartnerCoursePackage>(x => x.PartnerCoursePackageId == partnerCoursePackageId);
partnerCoursePackageEntryInDb.CoursePackageId = putPartnerCoursePackageDTO.CoursePackageId;
partnerCoursePackageEntryInDb.ContentStatusId = putPartnerCoursePackageDTO.ContentStatusId;
partnerCoursePackageEntryInDb.CreatedBy = putPartnerCoursePackageDTO.CreatedBy;
partnerCoursePackageEntryInDb.CreatedDate = putPartnerCoursePackageDTO.CreatedDate;
partnerCoursePackageEntryInDb.LastModified = putPartnerCoursePackageDTO.LastModified;
partnerCoursePackageEntryInDb.LastModifiedBy = putPartnerCoursePackageDTO.LastModifiedBy;
partnerCoursePackageEntryInDb.Offered = putPartnerCoursePackageDTO.Offered;
partnerCoursePackageEntryInDb.Price = putPartnerCoursePackageDTO.Price;
//PartnerPackageIncludedItem
var allPartnerPackageIncludedItemsInDb = _choiceRepository.GetAll <PartnerPackageIncludedItem>(x => x.PartnerCoursePackageId == partnerCoursePackageEntryInDb.PartnerCoursePackageId);
// First remove all
foreach (var partnerPackageIncludedItem in allPartnerPackageIncludedItemsInDb)
{
_choiceRepository.Remove <PartnerPackageIncludedItem>(partnerPackageIncludedItem);
}
foreach (var packageIncludedItemDTO in putPartnerCoursePackageDTO.PartnerPackageIncludedItemDTOs)
{
PartnerPackageIncludedItem partnerPackageIncludedItem = new PartnerPackageIncludedItem();
partnerPackageIncludedItem.PartnerCoursePackageId = partnerCoursePackageEntryInDb.PartnerCoursePackageId;
partnerPackageIncludedItem.PackageIncludedItemId = packageIncludedItemDTO.PackageIncludedItemId;
partnerPackageIncludedItem.CreatedBy = packageIncludedItemDTO.CreatedBy;
partnerPackageIncludedItem.CreatedDate = packageIncludedItemDTO.CreatedDate;
partnerPackageIncludedItem.LastModified = packageIncludedItemDTO.LastModified;
partnerPackageIncludedItem.LastModifiedBy = packageIncludedItemDTO.LastModifiedBy;
partnerPackageIncludedItem.Offered = packageIncludedItemDTO.Included;
_choiceRepository.Add <PartnerPackageIncludedItem>(partnerPackageIncludedItem);
}
//PartnerPackageAdditionalItem
var allPartnerPackageAdditionalItemInDb = _choiceRepository.GetAll <PartnerPackageAdditionalItem>(x => x.PartnerCoursePackageId == partnerCoursePackageEntryInDb.PartnerCoursePackageId);
// First remove all
foreach (var partnerPackageAdditionalItem in allPartnerPackageAdditionalItemInDb)
{
_choiceRepository.Remove <PartnerPackageAdditionalItem>(partnerPackageAdditionalItem);
}
foreach (var partnerPackageAdditionalItemDTO in putPartnerCoursePackageDTO.PartnerPackageAdditionalItemDTOs)
{
PartnerPackageAdditionalItem partnerPackageAdditionalItem = new PartnerPackageAdditionalItem();
partnerPackageAdditionalItem.PartnerCoursePackageId = partnerCoursePackageEntryInDb.PartnerCoursePackageId;
partnerPackageAdditionalItem.CreatedBy = partnerPackageAdditionalItemDTO.CreatedBy;
partnerPackageAdditionalItem.CreatedDate = partnerPackageAdditionalItemDTO.CreatedDate;
partnerPackageAdditionalItem.LastModified = partnerPackageAdditionalItemDTO.LastModified;
partnerPackageAdditionalItem.LastModifiedBy = partnerPackageAdditionalItemDTO.LastModifiedBy;
partnerPackageAdditionalItem.Price = partnerPackageAdditionalItemDTO.Price;
partnerPackageAdditionalItem.UK = partnerPackageAdditionalItemDTO.UK;
partnerPackageAdditionalItem.DK = partnerPackageAdditionalItemDTO.DK;
_choiceRepository.Add <PartnerPackageAdditionalItem>(partnerPackageAdditionalItem);
}
//PartnerPackageYear
var allPartnerPackageYearsInDb = _choiceRepository.GetAll <PartnerPackageYear>(x => x.PartnerCoursePackageId == partnerCoursePackageEntryInDb.PartnerCoursePackageId);
// First remove all
foreach (var partnerPackageYearItem in allPartnerPackageYearsInDb)
{
_choiceRepository.Remove <PartnerPackageYear>(partnerPackageYearItem);
}
foreach (var partnerPackageAdditionalItemDTO in putPartnerCoursePackageDTO.PartnerPackageYearDTOs)
{
PartnerPackageYear partnerPackageYear = new PartnerPackageYear();
partnerPackageYear.PartnerCoursePackageId = partnerCoursePackageEntryInDb.PartnerCoursePackageId;
partnerPackageYear.CreatedBy = partnerPackageAdditionalItemDTO.CreatedBy;
partnerPackageYear.CreatedDate = partnerPackageAdditionalItemDTO.CreatedDate;
partnerPackageYear.LastModified = partnerPackageAdditionalItemDTO.LastModified;
partnerPackageYear.LastModifiedBy = partnerPackageAdditionalItemDTO.LastModifiedBy;
partnerPackageYear.PricePerPerson = partnerPackageAdditionalItemDTO.PricePerPerson;
partnerPackageYear.Year = partnerPackageAdditionalItemDTO.Year;
_choiceRepository.Add <PartnerPackageYear>(partnerPackageYear);
}
_choiceRepository.Complete();
var crmPartner = _choiceRepository.GetById <CRMPartner>(x => x.CRMPartnerId == partnerCoursePackageEntryInDb.CRMPartnerId);
crmPartner.LastModified = DateTime.UtcNow;
crmPartner.LastModifiedBy = "CloudMission";
_choiceRepository.Attach(crmPartner);
_choiceRepository.Complete();
return(NoContent());
}
public async Task <IActionResult> CreatePartner([FromBody] CRMPartnerDTO dto)
{
try
{
if (string.IsNullOrEmpty(dto.AccountId))
{
ModelState.AddModelError("AccountId", "AccountId can't be null");
return(BadRequest(ModelState));
}
if (dto == null)
{
ModelState.AddModelError("Partner", "Partner object can't be null");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var partner = _choiceRepoistory.GetById <CRMPartner>(c => c.AccountId == dto.AccountId);
if (partner != null)
{
ModelState.AddModelError("Partner", $"Partner entry already exist for AccountId {dto.AccountId}.");
return(BadRequest(ModelState));
}
// if partner type is "partner then assign membershiptype.
if (!string.IsNullOrWhiteSpace(dto.Partnertype) && dto.Partnertype.ToLower() == "partner")
{
dto.Partnertype = dto.MembershipType;
}
CRMPartner newlyCreatedPartner = _mapper.Map <CRMPartnerDTO, CRMPartner>(dto);
newlyCreatedPartner.CreatedBy = User.GetUserName();;
newlyCreatedPartner.CreatedDate = DateTime.UtcNow;
newlyCreatedPartner.LastModified = DateTime.UtcNow;
newlyCreatedPartner.LastModifiedBy = User.GetUserName();;
_choiceRepoistory.Add <CRMPartner>(newlyCreatedPartner);
if (bool.Parse(_configuration["SharePointIntegrationEnabled"].ToString()))
{
var sharePointId = await _sharePointService.InsertPartnerAsync(newlyCreatedPartner);
if (sharePointId <= 0)
{
return(StatusCode(500, "An error occurred while creating sharepoint partner. Please try again or contact adminstrator"));
}
newlyCreatedPartner.SharePointId = sharePointId;
}
#region All related fileds
CreatePartnerRelatedTablesDefaultEntries(newlyCreatedPartner);
#endregion
_choiceRepoistory.Complete();
return(CreatedAtRoute("GetPartnerByAccountId", new { newlyCreatedPartner.AccountId }, dto));
}
catch (Exception ex)
{
// TODO : Add logging and decide on showing ex.message
return(StatusCode(500, "An error occurred while creating partner. Please try again or contact adminstrator"));
}
}