public void Execute(ArticlesDto request)
{
_validator.ValidateAndThrow(request);
var pictures = new Pictures
{
src = request.Pictures.src
};
_context.Pictures.Add(pictures);
_context.SaveChanges();
var article = new Article
{
Subject = request.Subject,
Text = request.Text,
PicturesId = pictures.Id,
UserId = _actor.Id
};
_context.Articles.Add(article);
_context.SaveChanges();
foreach (var c in request.Categories)
{
var categories = new ArticleCategories
{
ArticlesId = article.Id,
CategoryId = c.Id
};
_context.ArticleCategories.Add(categories);
_context.SaveChanges();
}
}
/// <inheritdoc />
public Result UpdateArticle(ArticlesDto articlesDto)
{
using var transaction = _context.Database.BeginTransaction();
try
{
var article = _context.Articleses.Find(articlesDto.Id);
article.Description = articlesDto.Description;
article.HtmlH1 = articlesDto.HtmlH1;
article.MetaDescription = articlesDto.MetaDescription;
article.MetaKeywords = articlesDto.MetaKeywords;
article.MetaTitle = articlesDto.MetaTitle;
article.Name = articlesDto.Name;
article.Sort = articlesDto.Sort;
article.Status = articlesDto.Status;
_context.Update(article);
_context.SaveChanges();
transaction.Commit();
return(Result.Ok());
}
catch (Exception e)
{
transaction.Rollback();
throw new ApplicationException(e.InnerException.Message ?? e.Message);
}
}
/// <inheritdoc />
public async Task <Result> AddArticle(ArticlesDto articlesDto)
{
var article = new Articles
{
Id = articlesDto.Id,
Description = articlesDto.Description,
HtmlH1 = articlesDto.HtmlH1,
MetaDescription = articlesDto.MetaDescription,
MetaKeywords = articlesDto.MetaKeywords,
MetaTitle = articlesDto.MetaTitle,
Name = articlesDto.Name,
Sort = articlesDto.Sort,
Status = articlesDto.Status
};
try
{
_context.Add(article);
_context.SaveChanges();
return(Result.Ok());
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void Execute(ArticlesDto request, int id)
{
_validator.ValidateAndThrow(request);
var post = _context.Articles.Find(id);
var pic = _context.Pictures.Find(post.PicturesId);
var postcat = _context.ArticleCategories.Where(x => x.ArticlesId == id).Select(x => x.Id).ToList();
post.Subject = request.Subject;
post.Text = request.Text;
post.UserId = request.UserId;
pic.src = request.Pictures.src;
// pic.alt = request.Pictures.alt;
post.Pictures.ModifiedAt = DateTime.Now;
post.ModifiedAt = DateTime.Now;
var brojKategorije = request.Categories;
foreach (var i in postcat)
{
var pc = _context.ArticleCategories.Find(i);
_context.ArticleCategories.Remove(pc);
}
foreach (var bk in brojKategorije)
{
var cat = new ArticleCategories
{
ArticlesId = id,
CategoryId = bk.Id
};
_context.ArticleCategories.Add(cat);
}
_context.SaveChanges();
}
public ActionResult CreateArticles(ArticlesDto articleDto) //delete previous articles and insert new ones
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var documentId = articleDto.DocumentId;
Document document = _context.Documents.SingleOrDefault(p => p.Id == documentId);
if (document == null) //this document does not exist
{
return(NotFound());
}
List <Article> articlesInDb = _context.Articles.Where(p => p.DocumentId == documentId).ToList();
foreach (var article in articlesInDb)
{
_context.Remove(article);
}
//if document exists, find all articles with its ID
foreach (var article in articleDto.Articles)
{
_context.Add(article);
}
_context.SaveChanges();
return(Ok());
}
/// <summary>
/// Lit le fichier dont le chemin est passé en paramètre et sort les anomalies du fichiers, les doublons dans
/// le fichier et le resultat. Les lignes avec des anomalies ne sont pas envoyés dans le resultat.
/// </summary>
/// <param name="ChosenFilePath">Le chemin du fichier.</param>
/// <param name="ExistingArticlesCountByRef">Dictionnaire des doublons.</param>
/// <param name="Anomalies">Les annomalies du fichier.</param>
/// <param name="Result">Les lignes du fichiers.</param>
private static void ReadFile(string ChosenFilePath, Dictionary <string, int> ExistingArticlesCountByRef,
Dictionary <int, string> Anomalies, List <ArticlesDto> Result)
{
CsvReader.ReadFile(ChosenFilePath, (Strings, LineNumber) =>
{
try
{
var RefArticle = Strings[1];
if (ExistingArticlesCountByRef.TryGetValue(RefArticle, out var PreviousLineDefinition))
{
Anomalies.Add(LineNumber,
$"Réference d'article en doublon (précédement défini à la ligne {PreviousLineDefinition})");
}
else
{
ExistingArticlesCountByRef.Add(RefArticle, LineNumber);
Result.Add(ArticlesDto.FromRawData(
// Description;Ref;Marque;Famille;Sous-Famille;Prix H.T.
RefArticle, Strings[0], Strings[3], Strings[4], Strings[2], Strings[5]));
}
}
catch (ParsingException ParsingException)
{
Anomalies.Add(LineNumber, ParsingException.Message);
}
});
}
/// <summary>
/// 点击
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnListViewItemTapped(object sender, Syncfusion.ListView.XForms.ItemTappedEventArgs e)
{
ArticlesDto baseMessageEntity = e.ItemData as ArticlesDto;
var messagDetailPage = new ArticlesDetailsPage(baseMessageEntity);
//await NavigationHelper.PushAsync(Navigation, messagDetailPage, false);
await Navigation.PushAsync(messagDetailPage);
}
private Articles Entity(ArticlesDto articlesDto)
{
return(new Articles()
{
StoreId = articlesDto.StoreId,
Id = articlesDto.Id,
Description = articlesDto.Description,
Name = articlesDto.Name,
Price = articlesDto.Price,
TotalInShelf = articlesDto.TotalInShelf,
TotalInVault = articlesDto.TotalInVault
});
}
public ActionResult <Response> Del([FromBody] ArticlesDto articleDto)
{
try
{
ArticlesManager articlesManager = new ArticlesManager();
articlesManager.Del(articleDto);
return(new Response("Se elimino correctamente la información.", TypeResponse.Success));
}
catch (Exception ex)
{
return(new Response("Ha ocurrido un error al eliminar la información.", TypeResponse.Error));
}
}
public void Execute(ArticlesDto request, int id)
{
_validator.ValidateAndThrow(request);
var article = _context.Articles.Find(id);
if (article == null)
{
throw new NotFoundEntityException(id, typeof(Articles));
}
article.Subject = request.Subject;
article.Text = request.Text;
article.Description = request.Description;
_context.SaveChanges();
}
/// <summary>
/// Metodo para eliminar un registro
/// </summary>
private void Delete()
{
var articleDto = new ArticlesDto()
{
Id = int.Parse(this.txtId.Text),
Name = this.txtName.Text,
Description = this.txtDescription.Text,
Price = decimal.Parse(this.txtPrice.Text),
TotalInShelf = int.Parse(this.txtTotalInShelf.Text),
TotalInVault = int.Parse(this.txtTotalInVault.Text),
StoreId = int.Parse(cbStore.SelectedValue.ToString())
};
ArticlesServices articleService = new ArticlesServices();
articleService.Delete(articleDto);
LoadGrid();
}
public ArticlesDto Execute(int search)
{
var post = _context.Articles.Find(search);
var categories = _context.ArticleCategories.Where(x => x.ArticlesId == search).Select(x => x.CategoryId).ToList();
var pic = _context.Pictures.Find(post.PicturesId);
var user = _context.Users.Find(post.UserId);
var cat = _context.Categories.Where(x => categories.Contains(x.Id));
var comments = _context.Comments.Where(x => x.ArticleId == post.Id);
var rates = _context.Rates.Where(x => x.ArticleId == post.Id);
var avg = rates.Select(x => x.RateNumber).Average();
var ct = cat.Select(d => new CategoryDto
{
Id = d.Id,
Name = d.Name
}).ToList();
var response = new ArticlesDto
{
Id = post.Id,
Subject = post.Subject,
Text = post.Text,
PicturesId = post.PicturesId,
UserId = post.UserId,
ProsecnaOcena = (float)avg,
User = new UserDto
{
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.Username
},
Pictures = new PicturesDto {
src = pic.src
// alt=pic.alt
},
Categories = ct,
Comments = comments.Select(x => new CommentDto {
text = x.Text,
Username = x.User.Username
}).ToList()
};
return(response);
}
/// <summary>
/// Metodo para eliminar un articulo
/// </summary>
/// <param name="articleDto">Objeto para que se guardado</param>
/// <returns>Mensaje de Respuesta</returns>
public Response Delete(ArticlesDto articleDto)
{
try
{
var action = "Articles/DelArticles";
var json = ServicesHelper.MethodPost(action, articleDto);
if (string.IsNullOrEmpty(json))
{
throw new Exception("Se ha producido un error al eliminar Articles");
}
return(JsonConvert.DeserializeObject <Response>(json));
}
catch (Exception ex)
{
return(new Response()
{
Mensaje = "Se ha producido un error al eliminar Articles", Resultado = false
});
}
}
public ActionResult <Response> Add([FromBody] ArticlesDto articleDto)
{
try
{
ArticlesManager articlesManager = new ArticlesManager();
if (articleDto.Id == 0)
{
articlesManager.Add(articleDto);
}
else
{
articlesManager.Upd(articleDto);
}
return(new Response("Se guardo correctamente la información.", TypeResponse.Success));
}
catch (Exception ex)
{
return(new Response("Ha ocurrido un error al guardar.", TypeResponse.Error));
}
}
/// <inheritdoc/>
public async Task <ArticlesDto> GetNewestArticlesAsync(int pageSize, int page)
{
var articlesCount = await _articleRepository.GetArticlesCountAsync();
var totalPages = (int)Math.Ceiling(articlesCount / (double)pageSize);
if (page > totalPages)
{
page = totalPages;
}
var articles = await _articleRepository.GetNewestArticlesAsync(pageSize, (page - 1) *pageSize);
var articleDtos = articles.Select(x => new ArticleDto
{
Author = new AuthorDto
{
FirstName = x.Author.FirstName,
LastName = x.Author.LastName
},
Id = x.Id,
Content = x.Content,
Description = x.Description,
PublishedAt = x.PublishedAt,
Title = x.Title
}).ToArray();
var articlesDto = new ArticlesDto
{
Articles = articleDtos,
Count = articlesCount,
PageSize = pageSize,
CurrentPage = page,
TotalPages = totalPages
};
return(articlesDto);
}
public Task <int> UpdateArticlesToSqlite(ArticlesDto message)
{
throw new NotImplementedException();
}
public void Add(ArticlesDto article)
{
this.Create(Entity(article));
}
public void Put(int id, [FromBody] ArticlesDto dto, [FromServices] IUpdateArticleCommand command)
{
executor.ExecuteCommandUpdate(command, dto, id);
}
public void Upd(ArticlesDto article)
{
this.Update(Entity(article));
}
public void Del(ArticlesDto article)
{
this.Delete(Entity(article));
}
public IActionResult Post([FromBody] ArticlesDto dto, [FromServices] ICreateArticleCommand command)
{
_executor.ExecuteCommand(command, dto);
return(NoContent());
}
public IActionResult Put(int id, [FromBody] ArticlesDto dto, [FromServices] IUpdateArticleCommand command)
{
_executor.ExecuteCommandUpdate(command, dto, id);
return(NoContent());
}
public async Task <IActionResult> AddArticle(ArticlesDto articlesDto)
{
var result = await _articleService.AddArticle(articlesDto);
return(Ok(result));
}
public IActionResult UpdateArticles(ArticlesDto articlesDto)
{
var result = _articleService.UpdateArticle(articlesDto);
return(Ok(result));
}
/// <summary>
/// 更新信息
/// </summary>
/// <returns></returns>
public async Task <int> UpdateArticlesToSqlite(ArticlesDto model)
{
return(await SqliteHelper.Current.db.UpdateAsync(model));
}
public ArticlesDetailsPage(ArticlesDto message)
{
InitializeComponent();
BindingContext = viewModel = new ArticlesDetailViewModel(message);
}
