/// <summary>
/// Save payment
/// </summary>
/// <param name="model">Payment model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper SavePayment(PaymentModel model)
{
try
{
using (var _context = new TDHEntities())
{
using (var trans = _context.Database.BeginTransaction())
{
try
{
decimal _currentYearMonth = decimal.Parse(DateTime.Now.DateToString("yyyyMM"));
MN_PAYMENT _md = new MN_PAYMENT();
_md.id = Guid.NewGuid();
_md.account_id = model.AccountID;
_md.category_id = model.CategoryID;
_md.title = model.Title;
_md.date = model.Date;
_md.purpose = model.Purpose;
_md.notes = model.Notes;
_md.money = model.Money;
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
_context.MN_PAYMENT.Add(_md);
_context.Entry(_md).State = EntityState.Added;
_context.SaveChanges();
//MN_ACCOUNT. Update account payment money
MN_ACCOUNT _acc = _context.MN_ACCOUNT.FirstOrDefault(m => m.id == _md.account_id);
_acc.output += model.Money;
_context.MN_ACCOUNT.Attach(_acc);
_context.Entry(_acc).State = EntityState.Modified;
_context.SaveChanges();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw new ServiceException(FILE_NAME, "SavePayment", model.CreateBy, ex);
}
}
}
}
catch (ServiceException serviceEx)
{
throw serviceEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "SavePayment", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(CheckListGroupModel model)
{
try
{
using (var context = new TDHEntities())
{
WK_CHECKLIST_GROUP _md = context.WK_CHECKLIST_GROUP.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
_md.deleted = true;
_md.delete_by = model.DeleteBy;
_md.delete_date = DateTime.Now;
context.WK_CHECKLIST_GROUP.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Delete", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(GroupModel model)
{
try
{
using (var context = new TDHEntities())
{
FB_GROUP _md = context.FB_GROUP.FirstOrDefault(m => m.uid == model.UID && m.created_by == model.CreateBy && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
context.FB_GROUP.Remove(_md);
context.Entry(_md).State = EntityState.Deleted;
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Delete", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Write error log to database
/// </summary>
/// <param name="fileName">File name</param>
/// <param name="methodName">method name</param>
/// <param name="userID">user action</param>
/// <param name="ex">Exception</param>
public static void WriteLog(string fileName, string methodName, Guid userID, Exception ex)
{
try
{
using (var context = new TDHEntities())
{
WEB_ERROR_LOG _md = new WEB_ERROR_LOG();
_md.id = Guid.NewGuid();
_md.file_name = fileName;
_md.method_name = methodName;
_md.source = ex.Source;
_md.stack_trace = "";// ex.StackTrace;
_md.inner_exception = ex.InnerException != null ? ex.InnerException.Message : "";
_md.message = ex.Message;
_md.date = DateTime.Now;
_md.create_date = DateTime.Now;
_md.create_by = userID;
context.WEB_ERROR_LOG.Add(_md);
context.Entry(_md).State = System.Data.Entity.EntityState.Added;
context.SaveChanges();
}
}
catch (Exception e)
{
Utils.ErrorLogger.TextLoggerHelper.OutputLog(e.Message);
}
}
/// <summary>
/// Get item
/// </summary>
/// <param name="model">About model</param>
/// <returns>AboutModel</returns>
public AboutModel GetItemByID(AboutModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_ABOUT _md = _context.WEB_ABOUT.FirstOrDefault(m => !m.deleted);
if (_md == null)
{
_md = new WEB_ABOUT()
{
id = Guid.NewGuid(),
content = "",
link = "",
image = "",
meta_title = "",
meta_description = "",
meta_keywords = "",
meta_article_name = "",
meta_article_publish = DateTime.Now,
meta_article_section = "",
meta_article_tag = "",
meta_next = "",
meta_og_image = "",
meta_og_site_name = "",
meta_twitter_image = "",
create_by = model.CreateBy,
create_date = DateTime.Now,
deleted = false,
};
_context.WEB_ABOUT.Add(_md);
_context.Entry(_md).State = EntityState.Added;
_context.SaveChanges();
}
return(new AboutModel()
{
ID = _md.id,
Content = _md.content,
Link = _md.link,
Image = _md.image,
MetaTitle = _md.meta_title,
MetaDescription = _md.meta_description,
MetaKeywords = _md.meta_keywords,
MetaNext = _md.meta_next,
MetaOgSiteName = _md.meta_og_site_name,
MetaOgImage = _md.meta_og_image,
MetaTwitterImage = _md.meta_twitter_image,
MetaArticleName = _md.meta_article_name,
MetaArticleTag = _md.meta_article_tag,
MetaArticleSection = _md.meta_article_section,
MetaArticlePublish = _md.meta_article_publish,
Insert = false
});
}
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "GetItemByID", model.CreateBy, ex);
}
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Skill defined model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(SkillDefinedModel model)
{
try
{
using (var _context = new TDHEntities())
{
CM_SKILL_DEFINDED _md = new CM_SKILL_DEFINDED();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.CM_SKILL_DEFINDED.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.skill_id = model.SkillID;
_md.name = model.Name;
_md.ordering = model.Ordering;
_md.description = model.Description;
_md.publish = true;
//Create or edit, only change the name and type
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
_context.CM_SKILL_DEFINDED.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
_context.CM_SKILL_DEFINDED.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model">Home category model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(HomeCategoryModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_HOME_CATEGORY _md = _context.WEB_HOME_CATEGORY.FirstOrDefault(m => m.category_id == model.CategoryID);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
_context.WEB_HOME_CATEGORY.Remove(_md);
_context.Entry(_md).State = EntityState.Deleted;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Delete", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Publish
/// </summary>
/// <param name="model">Category model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper OnNavigation(CategoryModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_CATEGORY _md = _context.WEB_CATEGORY.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "OnNavigation", model.CreateBy);
}
_md.show_on_nav = model.ShowOnNav;
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
_context.WEB_CATEGORY.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "OnNavigation", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Publish
/// </summary>
/// <param name="model">model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Publish(CetificateModel model)
{
try
{
using (var _context = new TDHEntities())
{
PN_CETIFICATE _md = _context.PN_CETIFICATE.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Publish", model.CreateBy);
}
_md.publish = model.Publish;
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
_context.PN_CETIFICATE.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Publish", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model">Account model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(AccountModel model)
{
try
{
using (var _context = new TDHEntities())
{
MN_ACCOUNT _md = _context.MN_ACCOUNT.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.create_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
_md.deleted = true;
_md.delete_by = model.DeleteBy;
_md.delete_date = DateTime.Now;
_context.MN_ACCOUNT.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Delete", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model">Skill defined model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(SkillDefinedModel model)
{
try
{
using (var _context = new TDHEntities())
{
CM_SKILL_DEFINDED _md = _context.CM_SKILL_DEFINDED.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
_context.CM_SKILL_DEFINDED.Remove(_md);
_context.Entry(_md).State = EntityState.Deleted;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(CetificateModel model)
{
try
{
using (var _context = new TDHEntities())
{
PN_CETIFICATE _md = new PN_CETIFICATE();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.PN_CETIFICATE.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.name = model.Name;
_md.school = model.School;
_md.time = model.Time;
_md.ordering = model.Ordering;
_md.publish = model.Publish;
//Setting value don't allow change when create or edit
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
_context.PN_CETIFICATE.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
_context.PN_CETIFICATE.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Dream model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(DreamModel model)
{
try
{
using (var context = new TDHEntities())
{
PN_DREAM _md = new PN_DREAM();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = context.PN_DREAM.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.title = model.Title;
_md.finish = model.Finish;
_md.finish_time = model.FinishTime;
_md.notes = model.Notes;
_md.ordering = model.Ordering;
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
context.PN_DREAM.Add(_md);
context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
context.PN_DREAM.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
}
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(CheckListItemModel model)
{
try
{
using (var context = new TDHEntities())
{
WK_CHECKLIST_ITEM _md = new WK_CHECKLIST_ITEM();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = context.WK_CHECKLIST_ITEM.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.title = model.title;
_md.description = model.description;
_md.update_date = model.updateDate;
if (model.Insert)
{
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
context.WK_CHECKLIST_ITEM.Add(_md);
context.Entry(_md).State = EntityState.Added;
}
else
{
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
context.WK_CHECKLIST_ITEM.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
}
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Account type model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(AccountTypeModel model)
{
try
{
using (var _context = new TDHEntities())
{
MN_ACCOUNT_TYPE _md = new MN_ACCOUNT_TYPE();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.MN_ACCOUNT_TYPE.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.name = model.Name;
_md.type = model.Type;
_md.ordering = model.Ordering;
_md.publish = model.Publish;
if (model.Insert)
{
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
_context.MN_ACCOUNT_TYPE.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
_context.MN_ACCOUNT_TYPE.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Account model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(AccountModel model)
{
try
{
using (var _context = new TDHEntities())
{
MN_ACCOUNT _md = new MN_ACCOUNT();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.MN_ACCOUNT.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.create_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.account_type_id = model.AccountTypeID;
_md.name = model.Name;
_md.max_payment = model.MaxPayment;
//Create or edit, only change the name and type
if (model.Insert)
{
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
_context.MN_ACCOUNT.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
_context.MN_ACCOUNT.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">List of group setting model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(List <GroupSettingModel> model)
{
try
{
using (var _context = new TDHEntities())
{
using (var trans = _context.Database.BeginTransaction())
{
try
{
foreach (var item in model)
{
MN_GROUP_SETTING _md = _context.MN_GROUP_SETTING.FirstOrDefault(m => m.id == item.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", item.CreateBy);
}
_md.percent_setting = item.PercentSetting;
_md.update_by = item.UpdateBy;
_md.update_date = DateTime.Now;
_context.MN_GROUP_SETTING.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
//
if (_md.year_month % 100 == DateTime.Now.Month)
{
var _gr = _context.MN_GROUP.FirstOrDefault(m => m.id == _md.group_id);
_gr.percent_setting = _md.percent_setting;
_context.MN_GROUP.Attach(_gr);
_context.Entry(_gr).State = EntityState.Modified;
}
_context.SaveChanges();
}
trans.Commit();
}
catch (DataAccessException fieldEx)
{
trans.Rollback();
throw fieldEx;
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model[0].CreateBy, ex);
}
Notifier.Notification(model[0].CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Category model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(CategoryModel model)
{
try
{
using (var _context = new TDHEntities())
{
MN_CATEGORY _md = new MN_CATEGORY();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.MN_CATEGORY.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.create_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.group_id = model.GroupID;
_md.name = model.Name;
_md.notes = model.Notes;
//Setting doesn't allow set in create or update
if (model.Insert)
{
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
_context.MN_CATEGORY.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
_context.MN_CATEGORY.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(FanpageModel model)
{
try
{
using (var context = new TDHEntities())
{
model.Insert = false;
FB_FANPAGE _md = new FB_FANPAGE();
_md = context.FB_FANPAGE.FirstOrDefault(m => m.uid == model.UID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
_md = new FB_FANPAGE();
_md.uid = model.UID;
model.Insert = true;
}
_md.link = model.Link;
_md.user_name = model.UserName;
_md.display_name = model.DisplayName;
_md.phone = model.Phone;
_md.email = model.Email;
_md.website = model.Website;
_md.auth_token = model.AuthToken;
_md.start_on = model.StartOn;
_md.last_execute = model.LastExecute;
_md.expires_on = model.ExpiresOn;
_md.ordering = model.Ordering;
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
context.FB_FANPAGE.Add(_md);
context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
context.FB_FANPAGE.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
}
context.SaveChanges();
}
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save all group by month
/// </summary>
/// <param name="yearMonth">Year month</param>
/// <param name="userID">The user identifier</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(decimal yearMonth, Guid userID)
{
try
{
using (var _context = new TDHEntities())
{
var _list = _context.MN_GROUP.Where(m => !m.deleted).ToList();
using (var trans = _context.Database.BeginTransaction())
{
try
{
foreach (var item in _list)
{
//Check if exists
var _stItem = _context.MN_GROUP_SETTING.FirstOrDefault(it => it.group_id == item.id && it.year_month == yearMonth && it.create_by == userID);
if (_stItem != null)
{
// Don't save new setting items if current is exists
continue;
}
MN_GROUP_SETTING _st = new MN_GROUP_SETTING()
{
id = Guid.NewGuid(),
group_id = item.id,
year_month = yearMonth,
percent_current = 0,
percent_setting = 0,
money_current = 0,
money_setting = 0,
create_by = userID,
create_date = DateTime.Now
};
_context.MN_GROUP_SETTING.Add(_st);
_context.Entry(_st).State = EntityState.Added;
_context.SaveChanges();
}
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
}
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", userID, ex);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="categoryID">The category identifier</param>
/// <param name="year">Year</param>
/// <param name="userID">The user identifier</param>
/// <returns>ResponseStatusCodeHelper</returns>
private ResponseStatusCodeHelper Create(Guid categoryID, int year, Guid userID)
{
try
{
using (var _context = new TDHEntities())
{
using (var trans = _context.Database.BeginTransaction())
{
try
{
year = year * 100;
//Save in 12 months in a year
for (int i = 1; i <= 12; i++)
{
MN_CATEGORY_SETTING _md = new MN_CATEGORY_SETTING()
{
id = Guid.NewGuid(),
category_id = categoryID,
year_month = year + i,
percent_current = 0,
percent_setting = 0,
money_current = 0,
money_setting = 0,
create_by = userID,
create_date = DateTime.Now,
deleted = false
};
_context.MN_CATEGORY_SETTING.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
_context.SaveChanges();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw new ServiceException(FILE_NAME, "Create", userID, ex);
}
}
}
}
catch (ServiceException servicedEx)
{
throw servicedEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Create", userID, ex);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(GroupModel model)
{
try
{
using (var context = new TDHEntities())
{
model.Insert = false;
FB_GROUP _md = new FB_GROUP();
_md = context.FB_GROUP.FirstOrDefault(m => m.uid == model.UID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
model.Insert = true;
_md = new FB_GROUP();
_md.uid = model.UID;
}
_md.link = model.Link;
_md.name = model.Name;
_md.ordering = model.Ordering;
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
context.FB_GROUP.Add(_md);
context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
context.FB_GROUP.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
}
context.SaveChanges();
}
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete all error log
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public ResponseStatusCodeHelper DeleteAll(Guid userID)
{
try
{
using (var context = new TDHEntities())
{
context.Database.ExecuteSqlCommand("TRUNCATE TABLE [dbo].[WEB_ERROR_LOG]");
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, MethodInfo.GetCurrentMethod().Name, userID, ex);
}
Notifier.Notification(userID, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Update Token
/// </summary>
/// <param name="model"></param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper UpdateToken(FanpageModel model)
{
try
{
using (var context = new TDHEntities())
{
FB_FANPAGE _md = context.FB_FANPAGE.FirstOrDefault(m => m.uid == model.UID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "UpdateToken", model.CreateBy);
}
_md.auth_token = model.AuthToken;
_md.start_on = model.StartOn;
_md.last_execute = model.LastExecute;
_md.expires_on = model.ExpiresOn;
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
context.FB_FANPAGE.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "UpdateToken", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">List of setting model</param>
/// <param name="userID">The user identifier</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(List <CategorySettingModel> model, Guid userID)
{
try
{
using (var _context = new TDHEntities())
{
using (var trans = _context.Database.BeginTransaction())
{
try
{
foreach (var item in model)
{
MN_CATEGORY_SETTING _md = _context.MN_CATEGORY_SETTING.FirstOrDefault(m => m.id == item.ID && m.category_id == item.CategoryID);
_md.money_setting = item.MoneySetting;
_context.MN_CATEGORY_SETTING.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw new ServiceException(FILE_NAME, "Save", userID, ex);
}
}
}
}
catch (ServiceException servicedEx)
{
throw servicedEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", userID, ex);
}
Notifier.Notification(userID, Message.UpdateSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Home category model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(HomeCategoryModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_HOME_CATEGORY _md = _md = _context.WEB_HOME_CATEGORY.FirstOrDefault(m => m.category_id == model.CategoryID);
if (!model.Selected)
{
return(Delete(model));
}
if (_md == null)
{
_md = new WEB_HOME_CATEGORY()
{
id = Guid.NewGuid(),
category_id = model.CategoryID,
ordering = 1
};
_context.WEB_HOME_CATEGORY.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.ordering = model.Ordering;
_context.WEB_HOME_CATEGORY.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Configuration model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(ConfigurationModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_CONFIGURATION _md = _context.WEB_CONFIGURATION.FirstOrDefault(m => m.key == model.Key);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
_md.key = model.Key;
_md.description = model.Description;
_md.value = model.Value;
_context.WEB_CONFIGURATION.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Delete
/// </summary>
/// <param name="model">Skill model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Delete(SkillModel model)
{
try
{
using (var _context = new TDHEntities())
{
CM_SKILL _md = _context.CM_SKILL.FirstOrDefault(m => m.id == model.ID && !m.deleted && m.created_by == model.CreateBy);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Delete", model.CreateBy);
}
_md.deleted = true;
_md.deleted_by = model.DeleteBy;
_md.deleted_date = DateTime.Now;
_context.CM_SKILL.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
var _lPerson = _context.PN_SKILL.Where(m => m.skill_id == _md.id).ToList();
if (_lPerson.Count > 0)
{
_context.PN_SKILL.RemoveRange(_lPerson);
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Delete", model.CreateBy, ex);
}
Notifier.Notification(model.CreateBy, Message.DeleteSuccess, Notifier.TYPE.Success);
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">Role Model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(RoleModel model)
{
try
{
using (var context = new TDHEntities())
{
using (var trans = context.Database.BeginTransaction())
{
try
{
SYS_ROLE _md = new SYS_ROLE();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = context.SYS_ROLE.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.name = model.Name;
_md.description = model.Description;
_md.publish = model.Publish;
if (model.Insert)
{
_md.created_by = model.CreateBy;
_md.created_date = DateTime.Now;
context.SYS_ROLE.Add(_md);
context.Entry(_md).State = EntityState.Added;
}
else
{
_md.updated_by = model.UpdateBy;
_md.updated_date = DateTime.Now;
context.SYS_ROLE.Attach(_md);
context.Entry(_md).State = EntityState.Modified;
//
var _lDetaiPerm = context.SYS_ROLE_DETAIL.Where(m => m.role_id == _md.id);
if (_lDetaiPerm.Count() > 0)
{
context.SYS_ROLE_DETAIL.RemoveRange(_lDetaiPerm);
}
}
foreach (var item in model.Detail)
{
SYS_ROLE_DETAIL _dt = new SYS_ROLE_DETAIL()
{
id = Guid.NewGuid(),
function_code = item.FunctionCode,
role_id = _md.id,
view = item.View,
add = item.Add,
edit = item.Edit,
delete = item.Delete
};
context.SYS_ROLE_DETAIL.Add(_dt);
context.Entry(_dt).State = EntityState.Added;
}
context.SaveChanges();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw new ServiceException(FILE_NAME, MethodInfo.GetCurrentMethod().Name, model.CreateBy, ex);
}
}
}
}
catch (ServiceException serviceEx)
{
throw serviceEx;
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, MethodInfo.GetCurrentMethod().Name, model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
/// <summary>
/// Save
/// </summary>
/// <param name="model">About model</param>
/// <returns>ResponseStatusCodeHelper</returns>
public ResponseStatusCodeHelper Save(AboutModel model)
{
try
{
using (var _context = new TDHEntities())
{
WEB_ABOUT _md = new WEB_ABOUT();
if (model.Insert)
{
_md.id = Guid.NewGuid();
}
else
{
_md = _context.WEB_ABOUT.FirstOrDefault(m => m.id == model.ID && !m.deleted);
if (_md == null)
{
throw new DataAccessException(FILE_NAME, "Save", model.CreateBy);
}
}
_md.content = model.Content;
_md.link = model.Link;
_md.image = model.Image;
_md.meta_title = model.MetaTitle;
_md.meta_description = model.MetaDescription;
_md.meta_keywords = model.MetaKeywords;
_md.meta_next = model.MetaNext;
_md.meta_og_site_name = model.MetaOgSiteName;
_md.meta_og_image = model.MetaOgImage;
_md.meta_twitter_image = model.MetaTwitterImage;
_md.meta_article_name = model.MetaArticleName;
_md.meta_article_tag = model.MetaArticleTag;
_md.meta_article_section = model.MetaArticleSection;
if (model.Insert)
{
_md.create_by = model.CreateBy;
_md.create_date = DateTime.Now;
_context.WEB_ABOUT.Add(_md);
_context.Entry(_md).State = EntityState.Added;
}
else
{
_md.update_by = model.UpdateBy;
_md.update_date = DateTime.Now;
_context.WEB_ABOUT.Attach(_md);
_context.Entry(_md).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (DataAccessException fieldEx)
{
throw fieldEx;
}
catch (Exception ex)
{
throw new ServiceException(FILE_NAME, "Save", model.CreateBy, ex);
}
if (model.Insert)
{
Notifier.Notification(model.CreateBy, Message.InsertSuccess, Notifier.TYPE.Success);
}
else
{
Notifier.Notification(model.CreateBy, Message.UpdateSuccess, Notifier.TYPE.Success);
}
return(ResponseStatusCodeHelper.Success);
}
