public PublishTaskProgressInfos(PublicationStatus status, string step, double?progress, bool canCancel, string errorMessage = null)
{
Status = status;
Step = step;
Progress = progress;
CanCancel = canCancel;
ErrorMessage = errorMessage;
}
public ActionResult DeleteConfirmed(Guid id)
{
PublicationStatus publicationStatus = db.PublicationStatus.Find(id);
db.PublicationStatus.Remove(publicationStatus);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void SubmitForEditing(string updatingUserName)
{
if (Status != PublicationStatus.Draft)
{
throw new ApplicationException("Can only submit Draft articles for editing.");
}
Status = PublicationStatus.NeedsEditing;
Save(updatingUserName);
}
public PublishingService(DatabaseContext context)
: base(context)
{
this.SetFinalRepository(context);
this.draftRepository = new DraftRepository <T2>(context);
this.publicationStatusRepository = new PublicationStatusRepository(context);
this.draftStatus = this.publicationStatusRepository.GetByName(Constants.PublicationStatusName.DRAFT);
this.published = this.publicationStatusRepository.GetByName(Constants.PublicationStatusName.PUBLISHED);
this.history = this.publicationStatusRepository.GetByName(Constants.PublicationStatusName.HISTORY);
}
public Publication Approve(PublicationStatus status, int id, User user)
{
var pub = Get(id);
if (user.Role == UserRole.Admin)
{
pub.Status = status;
db.SaveChanges();
}
return pub;
}
public ActionResult Create(ReviewModel model)
{
if (ModelState.IsValid)
{
PublicationStatus statusRascunho = this.publicationStatusRepository.GetByName(Constants.PublicationStatusName.DRAFT);
var draft = model.CreateDraftReviewFromModel(this.productService.GetByID(model.ProductId), null);
this.publishingService.CreateDraft(draft, draft.OriginReview);
return(RedirectToAction("Index"));
}
SetarViewBag();
return(View());
}
public async Task UpdateStatusAsync(string publicationId, PublicationStatus status)
{
try
{
var path = BaseUrl.UrlCombine(publicationId);
await HttpHelper.Put(path, new StatusDto { Status = status.ToString().ToLower() });
}
catch (Exception e)
{
throw new ProxyException(Constants.ExceptionMessages.DatabaseException, e);
}
}
public PublicationProgressEventArgs(int publicationHistoryId,
PublicationStatus status = PublicationStatus.Waiting,
string step = null,
double?progress = null,
bool canCancel = false,
string errorMessage = null)
{
PublicationHistoryId = publicationHistoryId;
Status = status;
Step = step;
Progress = progress;
CanCancel = canCancel;
ErrorMessage = errorMessage;
}
// GET: PublicationStatus/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PublicationStatus publicationStatus = db.PublicationStatus.Find(id);
if (publicationStatus == null)
{
return(HttpNotFound());
}
return(View(publicationStatus));
}
public void Approve(string updatingUserName)
{
if (!IsInRole(updatingUserName, "Administrator") &&
!IsInRole(updatingUserName, "Editor"))
{
throw new ApplicationException("Only editors and administrators can approve articles.");
}
if (Status != PublicationStatus.NeedsEditing)
{
throw new ApplicationException("Can only approve articles from the Needs Editing state.");
}
Status = PublicationStatus.Approved;
Save(updatingUserName);
}
public void PublishOnDate(string updatingUserName, DateTime dateToPublish)
{
if (!IsInRole(updatingUserName, "Administrator") &&
!IsInRole(updatingUserName, "Editor"))
{
throw new ApplicationException("Only editors and administrators can publish articles.");
}
if (Status != PublicationStatus.Approved)
{
throw new ApplicationException("Can only publish articles that have been approved.");
}
Status = PublicationStatus.Published;
DatePublished = dateToPublish;
Save(updatingUserName);
}
private void SaveNew(string updatingUserName)
{
if (!IsInRole(updatingUserName, "Author") &&
!IsInRole(updatingUserName, "Editor") &&
!IsInRole(updatingUserName, "Administrator"))
{
throw new ApplicationException("You do not have permission to create an article.");
}
AuthorUserName = updatingUserName;
DateCreated = DateTime.Now;
DateLastUpdated = DateTime.Now;
LastUpdatedByUserName = updatingUserName;
Status = PublicationStatus.Draft;
// save to database
}
public ActionResult Create([Bind(Include = "Name,Description")] PublicationStatus publicationStatus)
{
if (ModelState.IsValid)
{
publicationStatus.PublicationStatusID = Guid.NewGuid();
publicationStatus.DateCreated = DateTime.Now;
publicationStatus.DateModified = publicationStatus.DateCreated;
publicationStatus.UserCreatedID = Guid.Parse(User.Identity.GetUserId());
publicationStatus.UserModifiedID = publicationStatus.UserCreatedID;
db.PublicationStatus.Add(publicationStatus);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(publicationStatus));
}
public ActionResult Edit([Bind(Include = "PublicationStatusID,Name,Description")] PublicationStatusViewModel publicationStatusViewModel)
{
if (ModelState.IsValid)
{
PublicationStatus model = db.PublicationStatus.Find(publicationStatusViewModel.PublicationStatusID);
model.Name = publicationStatusViewModel.Name;
model.Description = publicationStatusViewModel.Description;
model.DateModified = DateTime.Now;
model.UserModifiedID = Guid.Parse(User.Identity.GetUserId());
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(publicationStatusViewModel));
}
public static void CheckIsNextStateValid(PublicationStatus currentState, PublicationStatus nextState, Role userRole)
{
var nextStatesDict = _nextStatesDict.GetValueOrDefault(currentState);
if (nextStatesDict == null)
{
throw new ValidationException("Next state does not exist for current state");
}
if (!nextStatesDict.TryGetValue(nextState, out Role role))
{
throw new ValidationException("Next state is not valid for current state");
}
if (role != userRole)
{
throw new ValidationException("User does not have premission to switch state");
}
}
public Task UpdateStatusAsync(string publicationId, PublicationStatus status)
{
return(_publicationDataAccess.UpdateStatusAsync(publicationId, status));
}
/// <summary>
/// Update a product's fields with this fields values
/// </summary>
/// <returns></returns>
public void UpdateProduct(auRant.Core.Entities.Product produtoEditavel, ProductCategory category, PublicationStatus productStatus, Supplier supplier)
{
produtoEditavel.Name = this.Name;
produtoEditavel.Category = category;
produtoEditavel.PublicationStatus = productStatus;
produtoEditavel.Price = this.Price;
produtoEditavel.Supplier = supplier;
produtoEditavel.urlImage = this.urlImage;
produtoEditavel.ShortDescription = this.ShortDescription;
produtoEditavel.FullDescription = this.FullDescription;
}
/// <summary>
/// Transforms itself into a Product entity
/// </summary>
/// <returns></returns>
public auRant.Core.Entities.Product CreateProduct(string urlImage, ProductCategory category, PublicationStatus productStatus, Supplier supplier)
{
return(new auRant.Core.Entities.Product()
{
Name = this.Name,
Category = category,
PublicationStatus = productStatus,
Price = this.Price,
Supplier = supplier,
urlImage = urlImage,
ShortDescription = this.ShortDescription,
FullDescription = this.FullDescription
});
}
/// <summary>
/// Receives and set the context for the repository
/// </summary>
/// <param name="context">The context</param>
public ProductRepository(DatabaseContext context)
: base(context)
{
this.publicationStatusRepository = new PublicationStatusRepository(context);
this.draftStatus = this.publicationStatusRepository.GetByName(Constants.PublicationStatusName.DRAFT);
}
public ActionResult Approve(int id, PublicationStatus status)
{
var user = Session["user"] as User;
var pub = pubViewModel.Approve(status, id, user);
return PartialView("Publication", pub);
}
public static List <Article> ListArticlesByStatus(PublicationStatus status)
{
throw new NotImplementedException();
}
public static void CheckIsNextStateValid(PublicationStatus currentState, string nextState, string userRole)
{
CheckIsNextStateValid(currentState, StatusStringToEnum(nextState), RoleStringToEnum(userRole));
}
