private SponsorListViewModel GetTrustViewModelList(dynamic response, string orderBy, int page)
{
var sponsorListVm = new List <SponsorViewModel>();
var vm = new SponsorListViewModel(sponsorListVm, null, orderBy);
if (response != null)
{
foreach (var result in response.Results)
{
var sponsorVm = new SponsorViewModel(result["MATNumber"], result["TrustOrCompanyName"], null, base.ExtractSchoolComparisonListFromCookie());
sponsorListVm.Add(sponsorVm);
}
vm.SchoolComparisonList = base.ExtractSchoolComparisonListFromCookie();
vm.Pagination = new Pagination
{
Start = (SearchDefaults.RESULTS_PER_PAGE * (page - 1)) + 1,
Total = response.NumberOfResults,
PageLinksPerPage = SearchDefaults.LINKS_PER_PAGE,
MaxResultsPerPage = SearchDefaults.RESULTS_PER_PAGE
};
}
return(vm);
}
public SponsorsPage()
{
InitializeComponent();
NavigationPage.SetHasBackButton(this, true);
BindingContext = model = new SponsorViewModel();
}
public ActionResult Create(SponsorViewModel sponsorViewModel)
{
var imageInfo = sponsorViewModel.Name + " Logo";
var imageValidation = sponsorViewModel.Logo.ValidateImageUpload();
if (imageValidation.ContainsKey("ModelError"))
{
ModelState.AddModelError("ImageUpload", imageValidation["ModelError"]);
}
if (ModelState.IsValid)
{
var sponsor = new Sponsor
{
Contact = sponsorViewModel.Contact,
Email = sponsorViewModel.Email,
Name = sponsorViewModel.Name,
Phone = sponsorViewModel.Phone,
TagLine = sponsorViewModel.TagLine,
SponsorMessage = sponsorViewModel.SponsorMessage,
WebSiteUrl = sponsorViewModel.WebSiteUrl
};
var url = sponsorViewModel.Logo.SaveImageUpload(_serverMapPathProvider, Constants.SponsorUploadDir);
var logo = new Image {
Title = imageInfo, AltText = imageInfo, ImageType = ImageType.Logo, ImageUrl = url
};
sponsor.Logo = logo;
_repository.Context.Add(sponsor);
_repository.Context.Commit();
return(RedirectToAction("Index"));
}
return(View(sponsorViewModel));
}
private SponsorViewModel ToSponsorViewModel(Sponsor sponsor)
{
if (sponsor == null)
{
return(null);
}
var _event = _context.Events.FirstOrDefault(e => e.EventId == sponsor.EventId);
var result = new SponsorViewModel
{
SponsorId = sponsor.SponsorId,
CompanyName = sponsor.CompanyName,
SponsorLevel = sponsor.SponsorLevel,
Bio = sponsor.Bio,
TwitterHandle = sponsor.TwitterHandle,
WebsiteUrl = sponsor.WebsiteUrl,
PointOfContact = sponsor.PointOfContact,
EmailAddress = sponsor.EmailAddress,
PhoneNumber = sponsor.PhoneNumber,
EventName = _event != null ? _event.Name : string.Empty
};
return(result);
}
public ActionResult Create(Sponsor sponsor, HttpPostedFileBase logo)
{
ModelState.Clear();
if (logo != null && logo.ContentLength > 0)
{
var ms = new MemoryStream();
logo.InputStream.CopyTo(ms);
sponsor.Logo = ms.ToArray();
sponsor.LogoContentType = logo.ContentType;
}
sponsor.Site = SiteService.LoadSite(Site, true);
sponsor.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
RepositoryFactory.SponsorRepository.EnsurePersistent(sponsor);
Message = "Sponsor was successfully created";
return(RedirectToAction("Index"));
}
var viewModel = SponsorViewModel.Create(sponsor);
return(View(viewModel));
}
public ActionResult Edit(int id, Sponsor sponsor, HttpPostedFileBase logo)
{
var sponsorToEdit = RepositoryFactory.SponsorRepository.GetNullableById(id);
if (sponsorToEdit == null)
{
Message = "Sponsor was not found.";
return(RedirectToAction("Index"));
}
if (logo != null && logo.ContentLength > 0)
{
var ms = new MemoryStream();
logo.InputStream.CopyTo(ms);
sponsorToEdit.Logo = ms.ToArray();
sponsorToEdit.LogoContentType = logo.ContentType;
}
AutoMapper.Mapper.Map(sponsor, sponsorToEdit);
ModelState.Clear();
sponsorToEdit.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
RepositoryFactory.SponsorRepository.EnsurePersistent(sponsorToEdit);
Message = "Sponsor was successfully updated";
return(RedirectToAction("Index"));
}
var viewModel = SponsorViewModel.Create(sponsor);
return(View(viewModel));
}
public ActionResult Edit(int id, SponsorViewModel sponsorViewModel)
{
var imageInfo = sponsorViewModel.Name + " Logo";
var imageValidation = sponsorViewModel.Logo.ValidateImage();
if (sponsorViewModel.Logo.ValidateImageUpload().ContainsKey("ModelError"))
{
ModelState.AddModelError("ImageUpload", imageValidation["ModelError"]);
}
if (ModelState.IsValid)
{
var url = sponsorViewModel.Logo.SaveImageUpload(_serverMapPathProvider, Constants.SponsorUploadDir);
var logo = new Image {
Title = imageInfo, AltText = imageInfo, ImageType = ImageType.Logo, ImageUrl = url
};
var sponsor = _repository.Find(new GetSponsorById(id));
sponsor.Contact = sponsorViewModel.Contact;
sponsor.Email = sponsorViewModel.Email;
sponsor.Name = sponsorViewModel.Name;
sponsor.Phone = sponsorViewModel.Phone;
sponsor.TagLine = sponsorViewModel.TagLine;
sponsor.SponsorMessage = sponsorViewModel.SponsorMessage;
sponsor.WebSiteUrl = sponsorViewModel.WebSiteUrl;
sponsor.Logo = logo;
_repository.Context.Commit();
return(RedirectToAction("Index"));
}
return(View(sponsorViewModel));
}
private async Task <SponsorViewModel> BuildSponsorVMAsync(string matNo, string name, dynamic response, RevenueGroupType tab, ChartGroupType chartGroup, MatFinancingType matFinancing)
{
var schoolListVM = new List <SchoolViewModel>();
foreach (var result in response.Results)
{
schoolListVM.Add(new SchoolViewModel(result, null));
}
var comparisonListVM = base.ExtractSchoolComparisonListFromCookie();
var sponsorVM = new SponsorViewModel(matNo, name, new SchoolListViewModel(schoolListVM, comparisonListVM), comparisonListVM);
sponsorVM.HistoricalCharts = _historicalChartBuilder.Build(tab, chartGroup, sponsorVM.FinancialType);
sponsorVM.ChartGroups = _historicalChartBuilder.Build(tab, sponsorVM.FinancialType).DistinctBy(c => c.ChartGroup).ToList();
sponsorVM.Terms = _financialDataService.GetActiveTermsForAcademies();
sponsorVM.HistoricalSchoolFinancialDataModels = await this.GetFinancialDataHistoricallyAsync(sponsorVM.MatNo, matFinancing);
if (sponsorVM.HistoricalSchoolFinancialDataModels.Count > 0)
{
sponsorVM.TotalRevenueIncome = sponsorVM.HistoricalSchoolFinancialDataModels.Last().TotalIncome;
sponsorVM.TotalRevenueExpenditure = sponsorVM.HistoricalSchoolFinancialDataModels.Last().TotalExpenditure;
sponsorVM.InYearBalance = sponsorVM.HistoricalSchoolFinancialDataModels.Last().InYearBalance;
}
return(sponsorVM);
}
// GET: Sponsor/Details/5
public ActionResult Details(int id)
{
var sponsorDetails = sponsor.GetById(id);
SponsorViewModel model = new SponsorViewModel();
model.InjectFrom(sponsorDetails);
return(View(model));
}
// GET: Sponsor/Edit/5
public ActionResult Edit(int id)
{
var getSponsorById = sponsor.GetById(id);
SponsorViewModel sponsors = new SponsorViewModel();
sponsors.InjectFrom(getSponsorById);
return(View(sponsors));
}
public HttpResponseMessage GetTopTenSponsors(HttpRequestMessage request)
{
var sponsors = _studentApi.GetTopTenSponsors();
var sponsorVm = SponsorViewModel.MultipleSponsorsMap(sponsors);
var response = request.CreateResponse(HttpStatusCode.OK, sponsorVm);
return(response);
}
// GET: Sponsor/Delete/5
public ActionResult Delete(int id)
{
var deleteSponsor = sponsor.GetById(id);
SponsorViewModel model = new SponsorViewModel();
model.InjectFrom(deleteSponsor);
return(View(model));
}
public ActionResult Delete(int id, SponsorViewModel model)
{
Sponsors deleteSponsor = new Sponsors();
deleteSponsor = sponsor.GetById(id);
model.InjectFrom(deleteSponsor);
sponsor.DeleteSponsor(deleteSponsor);
return(RedirectToAction(nameof(Index)));
}
public HttpResponseMessage GetSponsor(HttpRequestMessage request, int userId)
{
var sponsor = _studentApi.GetSponsor(userId);
var model = new SponsorViewModel();
var sponsorVm = model.SingleSponsorMap(sponsor);
var response = request.CreateResponse(HttpStatusCode.OK, sponsorVm);
return(response);
}
public ActionResult Edit(int id)
{
var sponsor = RepositoryFactory.SponsorRepository.GetNullableById(id);
if (sponsor == null)
{
Message = "Sponsor was not found.";
return(RedirectToAction("Index"));
}
var viewModel = SponsorViewModel.Create(sponsor);
return(View(viewModel));
}
private void SafeSponsorImage(SponsorViewModel model, Sponsor existingSponsor)
{
if (model.UploadImage != null)
{
string filename = existingSponsor.Id + Path.GetExtension(model.UploadImage.FileName);
_fileUtility.SaveImage(model.UploadImage.OpenReadStream(),
"sponsors",
"images",
filename,
new Size(_configuration.GetValue <int>("Images:Sponsors:X"),
_configuration.GetValue <int>("Images:Sponsors:Y")));
existingSponsor.Logo = filename;
}
}
public async Task <IActionResult> Edit(int id,
[Bind("SponsorId,CompanyName,SponsorLevel,Bio,TwitterHandle,WebsiteUrl,ImageFile,PointOfContact,EmailAddress,PhoneNumber")] SponsorViewModel sponsorVM)
{
if (ModelState.IsValid)
{
if (id != sponsorVM.SponsorId)
{
return(NotFound());
}
var sponsor = await _sponsorBL.GetSponsor(sponsorVM.SponsorId);
sponsor.CompanyName = sponsorVM.CompanyName;
sponsor.SponsorLevel = sponsorVM.SponsorLevel;
sponsor.Bio = sponsorVM.Bio;
sponsor.TwitterHandle = sponsorVM.TwitterHandle;
sponsor.WebsiteUrl = sponsorVM.WebsiteUrl;
sponsor.PointOfContact = sponsorVM.PointOfContact;
sponsor.EmailAddress = sponsorVM.EmailAddress;
sponsor.PhoneNumber = sponsorVM.PhoneNumber;
// Convert the image to a byte array, reduce the size to 500px x 500px
// and store it in the database
if (sponsorVM.ImageFile != null &&
sponsorVM.ImageFile.ContentType.ToLower().StartsWith("image/") &&
sponsorVM.ImageFile.Length <= SponsorViewModel.MaxImageSize)
{
MemoryStream ms = new MemoryStream();
sponsorVM.ImageFile.OpenReadStream().CopyTo(ms);
sponsor.Image
= _sponsorBL.ResizeImage(ms.ToArray());
}
var result = await _sponsorBL.UpdateSponsor(sponsor);
if (result == false)
{
return(NotFound());
}
else
{
return(RedirectToAction(nameof(Index)));
}
}
ViewBag.SponsorshipLevels = SponsorLevel.GetSponsorshipLevels();
return(View(sponsorVM));
}
public async Task <Sponsor> CreateSponsorAsync(SponsorViewModel model)
{
try
{
var sponsor = mapper.Map <Sponsor>(model);
var created = await repository.CreateSponsorAsync(sponsor);
return(await SaveAndReturn(created));
}
catch (Exception e)
{
throw e;
}
}
public ActionResult Sponsors_CreateById(SponsorViewModel c)
{
// if (c.StaffId > 0)
{
var entity = new Sponsor
{
// StaffId = 0,
Id = 1
};
_Service.Save(entity);
}
return(View());// RedirectToAction("Index");
}
public ActionResult Edit(int id, SponsorViewModel model)
{
if (ModelState.IsValid)
{
Sponsors sponsorsToCreate = new Sponsors();
sponsorsToCreate.InjectFrom(model);
sponsor.Update(sponsorsToCreate);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(model));
}
}
public async void Init_ExceptionThrown_ReportsError()
{
DataClient.GetDataBody = delegate { throw new Exception(); };
string errorMessage = null;
Messenger.Subscribe <ErrorMessage>(msg => errorMessage = msg.Message);
var viewModel = new SponsorViewModel(Messenger, CodeCampService, WebBrowserTask);
await viewModel.Init(new SponsorViewModel.NavigationParameters(42));
Assert.NotNull(errorMessage);
Assert.False(viewModel.IsLoading);
Assert.Null(viewModel.Sponsor);
}
private async Task <SponsorViewModel> CreateViewmodel(Sponsor sponsor = null)
{
if (sponsor == null)
{
sponsor = new Sponsor();
}
var model = new SponsorViewModel()
{
TrackedSponsor = sponsor,
AvailableSponsorLevels = await db.SponsorLevels.OrderBy(l => l.Rank).ToListAsync(),
SubmittedSponsorLevel = "",
};
return(model);
}
public async Task <ActionResult> Create(SponsorViewModel sponsor)
{
if (ModelState.IsValid)
{
sponsor.TrackedSponsor.Id = Guid.NewGuid().ToString();
sponsor.TrackedSponsor.SponsorLevel = await GetSponsorLevelForId(sponsor.SubmittedSponsorLevel);
db.Sponsors.Add(sponsor.TrackedSponsor);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(sponsor));
}
private Entities.Sponsor CreateTestSponsor(SponsorViewModel model)
{
var created = new Entities.Sponsor
{
Id = (sponsors.Count + 1).ToString(),
ContactEmail = "*****@*****.**",
ContactFirstName = "Test 2",
ContactLastName = "Test 2",
ContactPhone = "905-123-4567",
Name = "Test Sponsor 2"
};
sponsors.Add(created);
return(created);
}
private async Task GenerateDataToShow(string id)
{
var events = _context.Events.Include(x => x.Sponsors)
.ThenInclude(s => s.Sponsor)
.Where(x => x.Sponsors.Any(s => s.SponsorId == id))
.ToList();
var groupDetail = (await _meetupService.GroupDetail()).results[0];
var sponsor = _context.Sponsors.Where(x => x.Name == id).FirstOrDefault();
Sponsor = (await _meetupService.GroupDetail()).results[0].sponsors?.Select(x => new SponsorViewModel(x, sponsor))
.ToList()
.FirstOrDefault(s => s.Name == id);
Events = events?.Select(x => new EventViewModel(x)).ToList();
Photos = (await _meetupService.GetPhotos(events.Select(x => x.Id).ToList(), 50)).Select(x => new PhotoViewModel(x)).ToList();
}
// GET: Sponsors/Edit/5
public ActionResult Edit(int id)
{
var sponsor = _repository.Find(new GetSponsorById(id));
var viewModel = new SponsorViewModel
{
Contact = sponsor.Contact,
Email = sponsor.Email,
Name = sponsor.Name,
Phone = sponsor.Phone,
TagLine = sponsor.TagLine,
SponsorMessage = sponsor.SponsorMessage,
WebSiteUrl = sponsor.WebSiteUrl,
LogoUrl = sponsor.Logo.ImageUrl
};
return(View(viewModel));
}
// GET: Sponsors/Details/5
public ActionResult Details(int id)
{
var sponsor = _repository.Find(new GetSponsorById(id));
var viewModel = new SponsorViewModel
{
Id = sponsor.Id,
Contact = sponsor.Contact,
Email = sponsor.Email,
Name = sponsor.Name,
Phone = sponsor.Phone,
TagLine = sponsor.TagLine,
SponsorMessage = sponsor.SponsorMessage,
WebSiteUrl = sponsor.WebSiteUrl,
LogoUrl = sponsor.Logo != null ? sponsor.Logo.ImageUrl : string.Empty,
};
return(View(viewModel));
}
public async Task <ActionResult <Sponsor> > CreateSponsor([FromBody] SponsorViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var created = await sponsorService.CreateSponsorAsync(model);
return(CreatedAtAction(nameof(GetSponsorById), new { sponsorId = created.Id }, created));
}
catch (Exception e)
{
return(await HandleControllerException(e));
}
}
public async Task <IActionResult> Create([Bind("SponsorId,CompanyName,SponsorLevel,Bio,TwitterHandle,WebsiteUrl,ImageFile,PointOfContact,EmailAddress,PhoneNumber")] SponsorViewModel sponsorVM)
{
if (ModelState.IsValid)
{
var theEvent = await _eventBL.GetActiveEvent();
if (theEvent != null)
{
var sponsor = new Sponsor
{
SponsorId = sponsorVM.SponsorId,
CompanyName = sponsorVM.CompanyName,
SponsorLevel = sponsorVM.SponsorLevel,
Bio = sponsorVM.Bio,
TwitterHandle = sponsorVM.TwitterHandle,
WebsiteUrl = sponsorVM.WebsiteUrl,
PointOfContact = sponsorVM.PointOfContact,
EmailAddress = sponsorVM.EmailAddress,
PhoneNumber = sponsorVM.PhoneNumber,
EventId = theEvent.EventId
};
// Convert the image to a byte array, reduce the size to 500px x 500px
// and store it in the database
if (sponsorVM.ImageFile != null &&
sponsorVM.ImageFile.ContentType.ToLower().StartsWith("image/") &&
sponsorVM.ImageFile.Length <= SponsorViewModel.MaxImageSize)
{
MemoryStream ms = new MemoryStream();
sponsorVM.ImageFile.OpenReadStream().CopyTo(ms);
sponsor.Image
= _sponsorBL.ResizeImage(ms.ToArray());
}
await _sponsorBL.CreateSponsor(sponsor);
return(RedirectToAction(nameof(Index)));
}
}
ViewBag.SponsorshipLevels = SponsorLevel.GetSponsorshipLevels();
return(View(sponsorVM));
}
public async Task <SponsorViewModel> SaveEventSponsor([FromBody] SponsorViewModel model)
{
if (ModelState.IsValid)
{
try
{
var session = await _sessionProvider.Get();
SaveSponsorCommandResult saveSponsorCommandResult = await _commandSender.Send <SaveSponsorCommand, SaveSponsorCommandResult>(new SaveSponsorCommand
{
SponsorDetail = model.SponsorDetails,
EventId = model.EventId,
CurrentStep = model.CurrentStep,
ModifiedBy = session.User != null ? session.User.AltId : Guid.Parse("7390283B-4A32-4860-BA3D-B57F1E5F2DAC")
});
if (saveSponsorCommandResult.Success)
{
return(new SponsorViewModel
{
Success = true,
SponsorDetails = saveSponsorCommandResult.SponsorDetail,
CurrentStep = saveSponsorCommandResult.CurrentStep,
CompletedStep = saveSponsorCommandResult.CompletedStep
});
}
else
{
return(new SponsorViewModel {
});
}
}
catch (Exception e)
{
return(new SponsorViewModel {
});
}
}
else
{
return(new SponsorViewModel {
});
}
}
