public ActionResult Create(AddBlogArticleModel model)
{
try
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var membershipUser = Membership.GetUser();
var userId = (Guid)membershipUser.ProviderUserKey;
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
var blogArticle = blogArticleMapper.Map(model, userId);
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
blogProcess.AddBlogArticle(blogArticle);
return RedirectToAction("Index");
}));
}
catch (Exception)
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(View(model));
}
}
public async Task <ActionResult> Photos()
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoProcess>(container);
var entities = process.GetPhotos()
.ToList();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoAdapterSettingsMapper>(container);
var model = mapper.Map(entities);
return PartialView("/Views/Photo/_Photos.cshtml", model);
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(PartialView("/Views/Photo/_Photos.cshtml", new ItemListModel <PhotoDetailsModel> {
Title = "Photos", Items = new List <PhotoDetailsModel>()
}));
}
}
public async Task <ActionResult> UploadPhoto(string dummy)
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoProcess>(container);
foreach (var fileName in Request.Files.AllKeys)
{
var file = Request.Files[fileName];
if (file == null)
{
continue;
}
process.AddPhoto(file.InputStream, file.FileName);
}
return View();
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(View());
}
}
private void SetBandIdCookie(RequestContext requestContext)
{
const string cookieNameBandId = "BandId";
CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
Guid bandId;
var bandCookie = requestContext.HttpContext.Request.Cookies[cookieNameBandId];
if (bandCookie != null && !string.IsNullOrEmpty(bandCookie.Value))
{
bandId = Guid.Parse(bandCookie.Value);
}
else
{
var bandProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandProcess>(container);
bandId = bandProcess.EnsureBandExists().Id;
requestContext.HttpContext.Response.Cookies[cookieNameBandId].Value = bandId.ToString();
}
var bandIdInstaller = DependencyConfiguration.DependencyResolver.Resolve <IBandIdInstaller>();
bandIdInstaller.SetBandId(bandId);
});
}
public async Task <ActionResult> Video(int count)
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IVideoProcess>(container);
var entities = process.GetVideos(0, count)
.ToList();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IVideoAdapterSettingsMapper>(container);
var model = mapper.Map(entities);
return PartialView("_VideoSummary", model);
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(PartialView("_VideoSummary", new ItemListModel <VideoDetailsModel> {
Title = "Video", Items = new List <VideoDetailsModel>()
}));
}
}
public async Task <ActionResult> Index()
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioProcess>(container);
var entities = process.GetAudioTracks()
.ToList();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioAdapterSettingsMapper>(container);
var model = mapper.Map(entities);
return View(model);
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(View(new ItemListModel <AudioDetailsModel> {
Title = "Music", Items = new List <AudioDetailsModel>()
}));
}
}
public async Task Delete(Guid bandId, Guid id)
{
await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
var blogArticle = blogProcess.GetBlogArticle(id);
blogProcess.RemoveBlogArticle(blogArticle);
});
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
var statusCode = MembershipCreateStatus.Success;
var membershipUser = CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = userProcess.GetUserByLoginName(username);
if (user != null)
{
statusCode = MembershipCreateStatus.DuplicateUserName;
return(null);
}
user = userProcess.GetUserByEmailAddress(email);
if (user != null)
{
statusCode = MembershipCreateStatus.DuplicateEmail;
return(null);
}
var bandProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandProcess>(container);
var band = bandProcess.EnsureBandExists();
InstallBandId(band.Id);
var cryptographyProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <ICryptographyProcess>(container);
var encryptedPassword = cryptographyProcess.Encrypt(password);
user = new User
{
Login = new LoginAccount
{
LoginName = username,
Password = encryptedPassword,
EmailAddress = email,
IsApproved = isApproved,
IsOnline = true,
LastLoginDate = DateTime.UtcNow,
LastActivityDate = DateTime.UtcNow,
LastPasswordChangedDate = DateTime.UtcNow
},
};
user = userProcess.AddUser(user);
var userMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserMapper>(container);
return(userMapper.Map(user));
});
status = statusCode;
return(membershipUser);
}
public async Task Put(Guid bandId, Guid id, [FromBody] UpdateBlogArticleModel model)
{
await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
var blogArticle = blogArticleMapper.Map(model, id);
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
blogProcess.UpdateBlogArticle(blogArticle);
});
}
public async Task <AudioDetailsModel> GetAsync(Guid bandId, int id)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioProcess>(container);
var entity = process.GetAudioTrack(id);
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioAdapterSettingsMapper>(container);
return mapper.Map(entity);
}));
}
public async Task <IEnumerable <AudioDetailsModel> > GetAsync(Guid bandId, int page, int pageSize)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioProcess>(container);
var entities = process.GetAudioTracks(page, pageSize)
.ToList();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IAudioAdapterSettingsMapper>(container);
return mapper.Map(entities).Items;
}));
}
public async Task <ActionResult> Edit()
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync <ActionResult>(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoProcess>(container);
var entity = process.GetAdapterSettings();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoAdapterSettingsMapper>(container);
var model = mapper.MapToUpdate(entity);
return View(model);
}));
}
public async Task <ActionResult> EditAbout(AboutUpdateModel model)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandMapper>(container);
var entity = mapper.Map(model);
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandProcess>(container);
process.UpdateBand(entity);
return RedirectToAction("About");
}));
}
public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = process.GetUserByLoginAccount((Guid)providerUserKey);
InstallBandId(user.BandId);
var userMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserMapper>(container);
return userMapper.Map(user);
}));
}
public override MembershipUser GetUser(string userName, bool userIsOnline)
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = process.GetUserByLoginName(userName);
InstallBandId(user.BandId);
var userMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserMapper>(container);
return userMapper.Map(user);
}));
}
public async Task <ActionResult> EditAbout()
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandProcess>(container);
var entity = process.GetBand();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBandMapper>(container);
var model = mapper.MapToAboutUpdateModel(entity);
return View(model);
}));
}
//
// GET: /Performance/Details/5
public async Task <ActionResult> Details(Guid id)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceProcess>(container);
var entity = process.GetPerformance(id);
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceMapper>(container);
var model = mapper.MapToDetail(entity);
return View(model);
}));
}
public async Task <ActionResult> Performance(int count)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var performanceProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceProcess>(container);
var performances = performanceProcess.GetPerformances(0, count)
.ToList();
var performanceMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceMapper>(container);
var model = performanceMapper.Map(performances);
return PartialView("_PerformanceSummary", model);
}));
}
public void Post(Guid bandId, [FromBody] AddBlogArticleModel model)
{
CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var membershipUser = Membership.GetUser();
var userId = (Guid)membershipUser.ProviderUserKey;
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
var blogArticle = blogArticleMapper.Map(model, userId);
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
blogProcess.AddBlogArticle(blogArticle);
});
}
public async Task <BlogArticleDetailsModel> GetAsync(Guid bandId, Guid id)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
var blogArticle = blogProcess.GetBlogArticle(id);
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = userProcess.GetUser(blogArticle.AuthorId);
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
return blogArticleMapper.MapToDetail(blogArticle, user);
}));
}
public override string GetPassword(string username, string answer)
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = userProcess.GetUserByLoginName(username);
InstallBandId(user.BandId);
var cryptographyProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <ICryptographyProcess>(container);
return cryptographyProcess.Decrypt(user.Login.Password);
}));
}
public async Task <ActionResult> Future()
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceProcess>(container);
var entities = process.GetPerformances()
.ToList();
var mapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceMapper>(container);
var model = mapper.Map(entities);
return PartialView("_Future", model);
}));
}
public override bool UnlockUser(string userName)
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = process.GetUserByLoginName(userName);
InstallBandId(user.BandId);
user.Login.IsLockedOut = false;
process.UpdateUser(user);
return true;
}));
}
public override void UpdateUser(MembershipUser membershipUser)
{
CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var userMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserMapper>(container);
var user = userMapper.Map(membershipUser);
InstallBandId(user.BandId);
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
userProcess.UpdateUser(user);
return(true);
});
}
//
// GET: /BlogArticle/Details/5
public async Task <ActionResult> Details(Guid id)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
var blogArticle = blogProcess.GetBlogArticle(id);
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = userProcess.GetUser(blogArticle.AuthorId);
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
var model = blogArticleMapper.MapToDetail(blogArticle, user);
return View(model);
}));
}
public async Task <ActionResult> Edit(Guid id)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
// var membershipUser = Membership.GetUser();
// var userId = (Guid)membershipUser.ProviderUserKey;
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
var blogArticle = blogProcess.GetBlogArticle(id);
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
var model = blogArticleMapper.MapToUpdate(blogArticle);
return View(model);
}));
}
public async Task <ActionResult> Authorized()
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync <ActionResult>(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPhotoProcess>(container);
process.Authorize(Request.Url);
return RedirectToAction("Index");
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(View("Index"));
}
}
public async Task <IEnumerable <BlogArticleDetailsModel> > GetAsync(Guid bandId, int page, int pageSize)
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var blogProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogProcess>(container);
var blogArticles = blogProcess.GetBlogArticles(page, pageSize)
.ToList();
var authorIds = blogArticles
.Select(article => article.AuthorId)
.Distinct();
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var users = authorIds.Select(userProcess.GetUser);
var blogArticleMapper = CatalogsConsumerHelper.ResolveCatalogsConsumer <IBlogArticleMapper>(container);
return blogArticleMapper.Map(blogArticles, users).Items;
}));
}
public override bool ValidateUser(string username, string password)
{
return(CatalogsConsumerHelper.ExecuteWithCatalogScope(
container =>
{
var userProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <IUserProcess>(container);
var user = userProcess.GetUserByLoginName(username);
if (user == null)
{
return false;
}
InstallBandId(user.BandId);
var cryptographyProcess = CatalogsConsumerHelper.ResolveCatalogsConsumer <ICryptographyProcess>(container);
var currentPassword = cryptographyProcess.Decrypt(user.Login.Password);
return password == currentPassword;
}));
}
public async Task <ActionResult> Delete(Guid id)
{
try
{
return(await CatalogsConsumerHelper.ExecuteWithCatalogScopeAsync(
container =>
{
var process = CatalogsConsumerHelper.ResolveCatalogsConsumer <IPerformanceProcess>(container);
var entity = process.GetPerformance(id);
process.RemovePerformance(entity);
return RedirectToAction("Index");
}));
}
catch
{
ModelState.AddModelError("", ExceptionMessages.GenericExceptionMessage);
return(View("Edit"));
}
}
