public void Update(UserProfileDb profile)
{
if (profile != null)
{
context.Entry(profile).State = EntityState.Modified;
context.SaveChanges();
}
}
public async Task <Result <CourseCategoryDb> > UpdateAsync(CourseCategoryDb categoryDb)
{
try
{
if (categoryDb == null)
{
throw new ArgumentNullException("category");
}
context.Entry(categoryDb).State = EntityState.Modified;
await context.SaveChangesAsync().ConfigureAwait(false);
return(Result <CourseCategoryDb> .Ok(categoryDb));
}
catch (DbUpdateConcurrencyException e)
{
return((Result <CourseCategoryDb>) Result <CourseCategoryDb> .Fail <CourseCategoryDb>($"Cannot save category. {e.Message}"));
}
catch (DbUpdateException e)
{
return((Result <CourseCategoryDb>) Result <CourseCategoryDb> .Fail <CourseCategoryDb>($"Cannot save category. Duplicate field. {e.Message}"));
}
catch (DbEntityValidationException e)
{
return((Result <CourseCategoryDb>) Result <CourseCategoryDb> .Fail <CourseCategoryDb>($"Invalid category. {e.Message}"));
}
}
public async Task <Result <CourseDb> > UpdateAsync(CourseDb course)
{
try
{
context.Entry(course).State = EntityState.Modified;
await context.SaveChangesAsync().ConfigureAwait(false);
return(Result <CourseDb> .Ok(course));
}
catch (DbUpdateConcurrencyException e)
{
return((Result <CourseDb>) Result <CourseDb> .Fail <CourseDb>($"Cannot save course. {e.Message}"));
}
catch (DbEntityValidationException e)
{
return((Result <CourseDb>) Result <CourseDb> .Fail <CourseDb>($"Invalid course. {e.Message}"));
}
}
public async Task <Result <DomainDb> > UpdateAsync(DomainDb domainDb)
{
try
{
if (domainDb == null)
{
throw new ArgumentNullException("domain");
}
context.Entry(domainDb).State = EntityState.Modified;
await context.SaveChangesAsync().ConfigureAwait(false);
return(Result <CourseDb> .Ok(domainDb));
}
catch (DbUpdateConcurrencyException e)
{
return((Result <DomainDb>) Result <DomainDb> .Fail <DomainDb>($"Cannot save domain. {e.Message}"));
}
catch (DbEntityValidationException e)
{
return((Result <DomainDb>) Result <DomainDb> .Fail <DomainDb>($"Invalid domain. {e.Message}"));
}
}
public async Task <Result <SearchCriteriaDb> > UpdateAsync(SearchCriteriaDb criteriaDb)
{
try
{
context.Entry(criteriaDb).State = EntityState.Modified;
await context.SaveChangesAsync().ConfigureAwait(false);
//await DeleteAsync(criteriaDb);
//await AddAsync(criteriaDb);
return(Result <SearchCriteriaDb> .Ok(criteriaDb));
//SearchCriteriaDb criteria = context.SearchCriterias
//.FirstOrDefault(c => c.Id == criteriaDb.Id);
//List<DomainDb> domains = context.Domains.ToList();
//List<CourseCategoryDb> categories = context.CourseCategories.ToList();
//criteria.CourseCategories = categories.Where(x => criteriaDb.CourseCategories.Contains(x));
//order.Customer = customer;
//context.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
return(Result <SearchCriteriaDb> .Fail <SearchCriteriaDb>($"SearchCriteria not update. {e.Message}"));
}
catch (DbUpdateException e)
{
return(Result <SearchCriteriaDb> .Fail <SearchCriteriaDb>($"SearchCriteria not update. Duplicate field. {e.Message}"));
}
catch (DbEntityValidationException e)
{
return(Result <SearchCriteriaDb> .Fail <SearchCriteriaDb>($"Invalid SearchCriteria. {e.Message}"));
}
}
public void Update(T obj)
{
db.Entry(obj).State = EntityState.Modified;
}
public async Task <Result <IEnumerable <CourseDb> > > AddRangeAsync(IEnumerable <CourseDb> coursesDb)
{
try
{
List <CourseDb> listAddCourses = new List <CourseDb>();
List <CourseDb> listUpdateCourses = new List <CourseDb>();
CourseDb courseUpd;
DomainDb domain;
CourseCategoryDb category;
foreach (var courseNew in coursesDb)
{
courseUpd = context.Courses
.FirstOrDefault(x => x.URL == courseNew.URL);
if (courseUpd == null)
{
courseNew.Id = Guid.NewGuid().ToString();
domain = context.Domains.FirstOrDefault(x => x.DomainURL == courseNew.Domain.DomainURL);
if (domain != null)
{
courseNew.Domain = domain;
}
else
{
courseNew.Domain = await CreateDomainDbAsync(courseNew.Domain);
}
category = context.CourseCategories.FirstOrDefault(x => x.Name == courseNew.Category.Name);
if (category != null)
{
courseNew.Category = category;
}
else
{
courseNew.Category = await CreateCategoryDbAsync(courseNew.Category);
}
listAddCourses.Add(courseNew);
}
else
{
if (courseUpd.OldPrice != courseNew.Price)
{
courseUpd.DateOldPrice = DateTime.Now;
courseUpd.OldPrice = courseUpd.Price;
courseUpd.Price = courseNew.Price;
courseUpd.Discount = courseNew.Discount;
}
courseUpd.DateStartCourse = courseNew.DateStartCourse;
if (courseNew.Category != null && courseUpd.Category != null &&
courseUpd.Category.Name != courseNew.Category.Name)
{
courseUpd.Category = courseNew.Category;
}
courseUpd.Description = courseNew.Description;
if (courseNew.Domain != null && courseUpd.Domain != null &&
courseUpd.Domain.DomainURL != courseNew.Domain.DomainURL)
{
courseUpd.Domain = courseNew.Domain;
}
courseUpd.DateChange = DateTime.Now;
context.Entry(courseUpd).State = EntityState.Modified;
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
context.Courses.AddRange(listAddCourses);
await context.SaveChangesAsync().ConfigureAwait(false);
return(Result <IEnumerable <CourseDb> > .Ok(coursesDb));
}
catch (DbUpdateConcurrencyException e)
{
return(Result <IEnumerable <CourseDb> > .Fail <IEnumerable <CourseDb> >($"Cannot save course. {e.Message}"));
}
catch (DbUpdateException e)
{
return((Result <IEnumerable <CourseDb> >) Result <IEnumerable <CourseDb> > .Fail <IEnumerable <CourseDb> >($"Cannot save course. Duplicate field. {e.Message}"));
}
catch (DbEntityValidationException e)
{
return((Result <IEnumerable <CourseDb> >) Result <IEnumerable <CourseDb> > .Fail <IEnumerable <CourseDb> >($"Invalid course. {e.Message}"));
}
}