public async Task <ActionResult> Create(int id, FormCollection collection)
{
try
{
var creator = await UserFacade.GetUserAccordingToUsernameAsync(User.Identity.Name);
UserRole creatorUserRole;
if (!Enum.TryParse <UserRole>(creator.UserRole, out creatorUserRole))
{
return(View("~/Views/Home/GeneralExceptionView.cshtml"));
}
var ratedUser = await UserFacade.GetUserAsync(id);
UserRole ratedUserRole;
if (!Enum.TryParse <UserRole>(ratedUser.UserRole, out ratedUserRole))
{
return(View("~/Views/Home/GeneralExceptionView.cshtml"));
}
int ratingId = await RatingFacade.CreateRatingAsync(CreateRating(id, creator.Id, creatorUserRole, ratedUserRole, collection));
return(RedirectToAction("Details", ratedUserRole + "s", new { id = id }));
}
catch
{
return(View("~/Views/Home/GeneralExceptionView.cshtml"));
}
}
private async void RemoveUserRating(RatingDTO rating)
{
var ratings = await RatingFacade.ListRatingsAsync(new RatingFilterDTO { SearchedRatedUsersId = new[] { rating.RatedUserId } });
int ratingsCount = ratings.Items.Count();
if (rating.RatedUserRole == UserRole.Corporation)
{
var corporation = await UserFacade.GetCorporationAsync(rating.RatedUserId);
corporation.SumRating = DecreaseRating(corporation.SumRating.Value, ratingsCount, rating.Score);
corporation.RatingCount -= 1;
await UserFacade.EditCorporationAsync(corporation);
}
else
{
var freelancer = await UserFacade.GetFreelancerAsync(rating.RatedUserId);
freelancer.SumRating = DecreaseRating(freelancer.SumRating.Value, ratingsCount, rating.Score);
freelancer.RatingCount -= 1;
await UserFacade.EditFreelancerAsync(freelancer);
}
}
// GET: Ratings/Details/5
public async Task <ActionResult> Details(int id, string ratedUserName)
{
var rating = await RatingFacade.GetRatingsAsync(id);
var creator = await UserFacade.GetUserAsync(rating.CreatorId);
return(View("RatingDetailView", InitializeRatingViewModel(rating, creator.UserName, ratedUserName, rating.RatedUserId, rating.RatedUserRole.ToString())));
}
static void Main(string[] args)
{
//facade
DataManager dataManager = new DataManager();
ReviewManager reviewManager = new ReviewManager();
RatingFacade ratingPortal = new RatingFacade(dataManager, reviewManager);
ratingPortal.Start();
//proxy
List <string> resourses = new() { "EBEC", "Chess tournament", "WIPZ KR" };
UserRequest request = new UserRequest();
System.Console.WriteLine("\nSimulating work for unregistered User");
foreach (var res in resourses)
{
RealResource realResource = new RealResource(res);
Proxy proxy = new Proxy(realResource, 0); //unregistered user, wirh accessLevel = 0
request.Get(proxy);
}
System.Console.WriteLine("\nSimulating work for registered User");
foreach (var res in resourses)
{
RealResource realResource = new RealResource(res);
Proxy proxy = new Proxy(realResource, 1); //unregistered user, wirh accessLevel = 0
request.Get(proxy);
}
//composite
//student requesting info for PZ
Client client = new Client();
//PZ construction
System.Console.WriteLine("\n\nInfo about PZ\n");
Composite PZ = new Composite();
Composite Title = new Composite();
Title.Add(new Leaf("Title: Prog Zabezp"));
Composite Rating = new Composite();
Rating.Add(new Leaf("Rating: 10/12"));
Composite Content = new Composite();
Content.Add(new Leaf("Content: Nice stuff"));
Composite Comments = new Composite();
Comments.Add(new Leaf("Comments: How about Levus?"));
PZ.Add(new List <Component> {
Title, Rating, Content, Comments
});
//client.GetContent(PZ);
client.AddNewComponent(Comments, new Leaf("\tComment: not well..."));
client.GetContent(PZ);
}
}
public RatingFacadeTests()
{
var dbContextFactory = new DbContextInMemoryFactory(nameof(ActorFacadeTest));
var unitOfWork = new UnitOfWork(dbContextFactory);
repository = new Repository <RatingEntity>(unitOfWork);
mapper = new RatingMapper();
facadeTestUnit = new RatingFacade(unitOfWork, repository, mapper);
}
// GET: Ratings/Delete/5
public async Task <ActionResult> Delete(int id)
{
var rating = await RatingFacade.GetRatingsAsync(id);
RemoveUserRating(rating);
await RatingFacade.DeleteRatingAsync(id);
string userRoleListRoute = "~/Views/" + rating.RatedUserRole + "s/" + rating.RatedUserRole + "DetailView.cshtml";
return(RedirectToAction("Details", rating.RatedUserRole + "s", new { id = rating.RatedUserId }));
}
public async Task <ActionResult> Delete(int id, FormCollection collection)
{
try
{
var rating = await RatingFacade.GetRatingsAsync(id);
return(RedirectToAction("Index", "", null));
}
catch
{
return(View("~/Views/Home/GeneralExceptionView.cshtml"));
}
}
public FilmDetailViewModel(IMediator mediator,
FilmFacade filmFacade,
FilmActorFacade filmActorFacade,
FilmDirectorFacade filmDirectorFacade,
RatingFacade ratingFacade,
IConnectionService connectionService,
ISelectActorViewModel selectActorViewModel,
ISelectDirectorViewModel selectDirectorViewModel,
IRatingCreationService ratingCreationService,
IFileBrowserService fileBrowserService)
{
usedMediator = mediator;
usedFilmFacade = filmFacade;
usedFilmActorFacade = filmActorFacade;
usedFilmDirectorFacade = filmDirectorFacade;
usedRatingFacade = ratingFacade;
usedConnectionService = connectionService;
usedSelectActorViewModel = selectActorViewModel;
usedSelectDirectorViewModel = selectDirectorViewModel;
usedRatingCreationService = ratingCreationService;
usedFileBrowserService = fileBrowserService;
mediator.Register <NewMessage <FilmWrappedModel> >(CreateNewWrappedModel);
mediator.Register <SelectedMessage <FilmWrappedModel> >(PrepareFilm);
mediator.Register <MoveToDetailMessage <FilmActorWrappedModel> >(PrepareFilm);
mediator.Register <MoveToDetailMessage <FilmDirectorWrappedModel> >(PrepareFilm);
mediator.Register <MoveToDetailMessage <FilmWrappedModel> >(PrepareFilm);
mediator.Register <AddPersonToFilmMessage <ActorWrappedModel> >(AddActorToFilm);
mediator.Register <AddPersonToFilmMessage <DirectorWrappedModel> >(AddDirectorToFilm);
mediator.Register <AddRatingToFilmMessage <RatingWrappedListModel> >(AddRatingToFilm);
EditButtonCommand = new RelayCommand(EnableEditing);
SaveButtonCommand = new RelayCommand(Save, CanSave);
ActorSelectedCommand = new RelayCommand <FilmActorWrappedModel>(ActorSelected);
RemoveActorButtonCommand = new RelayCommand(RemoveActorFromList, RemoveActorEnabled);
AddActorButtonCommand = new RelayCommand(ShowActors);
DirectorSelectedCommand = new RelayCommand <FilmDirectorWrappedModel>(DirectorSelected);
RemoveDirectorButtonCommand = new RelayCommand(RemoveDirectorFromList, RemoveDirectorEnabled);
AddDirectorButtonCommand = new RelayCommand(ShowDirectors);
RatingSelectedCommand = new RelayCommand <RatingWrappedModel>(RatingSelected);
RemoveRatingButtonCommand = new RelayCommand(RemoveRatingFromList, RemoveRatingEnabled);
AddRatingButtonCommand = new RelayCommand(ShowRatingCreationWindow);
ActorListDoubleClickCommand = new RelayCommand <FilmActorWrappedModel>(MoveToActorDetail);
DirectorListDoubleClickCommand = new RelayCommand <FilmDirectorWrappedModel>(MoveToDirectorDetail);
UpdatePhotoButtonCommand = new RelayCommand(UpdatePhoto, UpdatePhotoEnabled);
GenreOptions = EnumExtensions.ConvertEnumToList <Genre>();
}
// GET: Corporations/Details/5
public async Task <ActionResult> Details(int id)
{
var model = await UserFacade.GetCorporationAsync(id);
var idOffers = await OfferFacade.ListOffersAsync(new OfferFilterDTO { SearchedAuthorsIds = new int[] { id } });
model.Offers = new List <OfferDTO>(idOffers.Items);
var appliedOffers = await OfferFacade.ListOffersAsync(new OfferFilterDTO { SearchedAppliersIds = new int[] { id } });
model.AppliedToOffers = new List <OfferDTO>(appliedOffers.Items);
var ratings = await RatingFacade.ListRatingsAsync(new RatingFilterDTO { SearchedRatedUsersId = new int[] { id } });
model.Ratings = await RatingHelper.MergeRatingsCreators(UserFacade, ratings.Items.ToList());
model.SumRating = RatingHelper.CountAverageRating(model.RatingCount, model.SumRating);
return(View("CorporationDetailView", model));
}
// GET: FreelancerController/Details/5
public async Task <ActionResult> Details(int id)
{
var model = await UserFacade.GetFreelancerAsync(id);
var user = await UserFacade.GetUserAsync(id);
var offers = await OfferFacade.ListOffersAsync(new OfferFilterDTO { SearchedAuthorsIds = new int[] { id } });
model.Offers = new List <OfferDTO>(offers.Items);
var appliedOffers = await OfferFacade.ListOffersAsync(new OfferFilterDTO { SearchedAppliersIds = new int[] { id } });
model.AppliedToOffers = new List <OfferDTO>(appliedOffers.Items);
var ratings = await RatingFacade.ListRatingsAsync(new RatingFilterDTO { SearchedRatedUsersId = new int[] { id } });
model.Ratings = await RatingHelper.MergeRatingsCreators(UserFacade, ratings.Items.ToList());
model.SumRating = RatingHelper.CountAverageRating(model.RatingCount, model.SumRating);
return(View("FreelancerDetailView", InitializeFreelancerDetailViewModel(model, user.UserName)));
}
public async Task <ActionResult> Edit(int id, FormCollection collection)
{
try
{
var newRating = await RatingFacade.GetRatingsAsync(id);
foreach (string key in collection.Keys)
{
switch (key)
{
case "Score":
int newScore;
if (Int32.TryParse(collection[key], out newScore))
{
newRating.Score = newScore;
}
break;
case "Comment":
newRating.Comment = collection[key];
break;
}
}
bool success = await RatingFacade.EditRatingAsync(newRating);
if (!success)
{
// THROW ERROR
}
return(RedirectToAction("Details", new { id = id }));
}
catch
{
return(View());
}
}
public AccountsController(UserFacade userFacade, OfferFacade offerFacade, RatingFacade ratingFacade)
{
this.userFacade = userFacade;
this.offerFacade = offerFacade;
this.ratingFacade = ratingFacade;
}
// GET: Ratings/Edit/5
public async Task <ActionResult> Edit(int id)
{
var rating = await RatingFacade.GetRatingsAsync(id);
return(View("RatingEditView", rating));
}
