/// <summary> /// Method to insert record /// </summary> /// <returns></returns> public bool Add() { using (var context = new SGGSEntities()) { var trim = new SGGS_CODE_TRIM_FORMAT { DATE_ADDED = DateTime.Now, DATE_UPDATED = DateTime.Now, TRIM_FORMAT_HEIGHT_IN = TRIM_FORMAT_HEIGHT_IN, TRIM_FORMAT_HEIGHT_MM = TRIM_FORMAT_HEIGHT_MM, TRIM_FORMAT_NAME = TRIM_FORMAT_NAME, TRIM_FORMAT_NUMBER = TRIM_FORMAT_NUMBER, TRIM_FORMAT_WIDTH_IN = TRIM_FORMAT_WIDTH_IN, TRIM_FORMAT_WIDTH_MM = TRIM_FORMAT_WIDTH_MM, USAGE_HARDCOVER = USAGE_HARDCOVER, USAGE_PAPERBACK = USAGE_PAPERBACK, SOFT_COVER = SOFT_COVER, HARD_COVER = HARD_COVER }; context.SGGS_CODE_TRIM_FORMAT.AddObject(trim); context.SaveChanges(); TRIM_FORMAT_ID = trim.TRIM_FORMAT_ID; return(true); } }
/// <summary> /// Method to Load values from DB by group Id /// </summary> /// <param name="GROUP_ID"></param> /// <returns></returns> public bool Load(long GROUP_ID) { using (SGGSEntities context = new SGGSEntities()) { var result = (from g in context.SGGS_GROUP where g.GROUP_ID == GROUP_ID select new { g.DATE_ADDED, g.DATE_UPDATED, g.DEFAULT_PUBLISHER_NUMBER, g.GROUP_CODE, g.GROUP_DESCRIPTION, g.GROUP_ID, g.GROUP_NAME }).FirstOrDefault(); if (result != null) { this.DATE_ADDED = result.DATE_ADDED.Value; this.DATE_UPDATED = result.DATE_UPDATED.Value; this.DEFAULT_PUBLISHER_NUMBER = result.DEFAULT_PUBLISHER_NUMBER; this.GROUP_CODE = result.GROUP_CODE; this.GROUP_DESCRIPTION = result.GROUP_DESCRIPTION; this.GROUP_ID = result.GROUP_ID; this.GROUP_NAME = result.GROUP_NAME; return(true); } return(false); } }
/// <summary> /// Method that adds new trim format to the duplicated print plant profile /// </summary> /// <returns></returns> public bool AddDuplicatedTrimFormats() { using (var context = new SGGSEntities()) { var trimFormat = new SGGS_SUPPORTED_TRIM_FORMATS { SUPPORTED_PAPER_TYPE_ID = SUPPORTED_PAPER_TYPE, SUPPORTED_BIND_TYPE_ID = SUPPORTED_BINDING_TYPE, PRINT_PLANT_PROFILE_ID = PRINT_PLANT_PROFILE_ID, TRIM_FORMAT_ID = TRIM_FORMAT_ID, TEXT_PAGE_COUNT_MAX = MAX_PAGES, TEXT_PAGE_COUNT_MIN = MIN_PAGES, TRIM_FORMAT_MIN_WIDTH = TRIM_FORMAT_MIN_WIDTH, TRIM_FORMAT_MAX_WIDTH = TRIM_FORMAT_MAX_WIDTH, TRIM_FORMAT_MAX_HEIGHT = TRIM_FORMAT_MAX_HEIGHT, TRIM_FORMAT_MIN_HEIGHT = TRIM_FORMAT_MIN_HEIGHT, OVERRIDE_AUTO_CALCULATION = OVERRIDE_AUTO_CALCULATION, SUPPORTED_PRINT_QUALITY = SUPPORTED_PRINT_QUALITY_ID }; context.SGGS_SUPPORTED_TRIM_FORMATS.AddObject(trimFormat); context.SaveChanges(); return(true); } }
/// <summary> /// Get Supported TrimFormat Information /// </summary> /// <param name="trimFormatId"></param> /// <returns></returns> public dynamic GetSupportedTrimFormatInformation(long trimFormatId) { using (var context = new SGGSEntities()) { var trimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS.AsEnumerable() .Where(x => x.SUPPORTED_TRIM_FORMATS_ID == trimFormatId) .Select(s => new { TRIM_FORMAT_ID = s.SUPPORTED_TRIM_FORMATS_ID, PAPER_TYPE = (from p in context.SGGS_PAPER_TYPE join sp in context.SGGS_SUPPORTED_PAPER_TYPE on p.PAPER_TYPE_ID equals sp.PAPER_TYPE_ID where sp.SUPPORTED_PAPER_TYPE_ID == s.SUPPORTED_PAPER_TYPE_ID select p.PAPER_NAME).FirstOrDefault(), BINDING_TYPE = (from b in context.SGGS_CODE_BINDING_TYPE join sb in context.SGGS_SUPPORTED_BIND_TYPE on b.BINDING_TYPE_ID equals sb.BINDING_TYPE_ID where sb.SUPPORTED_BIND_TYPE_ID == s.SUPPORTED_BIND_TYPE_ID select b.BINDING_TYPE_NAME).FirstOrDefault(), TRIM_FORMAT = context.SGGS_CODE_TRIM_FORMAT.Where(t => t.TRIM_FORMAT_ID == s.TRIM_FORMAT_ID).Select(ts => ts.TRIM_FORMAT_NAME).FirstOrDefault(), PRINT_QUALITY = context.SGGS_CODE_PRINT_QUALITY.Where(q => q.PRINT_QUALITY_ID == s.SUPPORTED_PRINT_QUALITY).Select(qs => qs.PRINT_QUALITY_NAME).FirstOrDefault(), MIN_PAGES = s.TEXT_PAGE_COUNT_MIN, MAX_PAGES = s.TEXT_PAGE_COUNT_MAX, WIDTH = (s.TRIM_FORMAT_MIN_WIDTH.HasValue ? s.TRIM_FORMAT_MIN_WIDTH.Value.ToString("G29"):"") + " - " + (s.TRIM_FORMAT_MAX_WIDTH.HasValue ? s.TRIM_FORMAT_MAX_WIDTH.Value.ToString("G29"):""), HEIGHT = (s.TRIM_FORMAT_MIN_HEIGHT.HasValue ? s.TRIM_FORMAT_MIN_HEIGHT.Value.ToString("G29"):"") + " - " + (s.TRIM_FORMAT_MAX_HEIGHT.HasValue? s.TRIM_FORMAT_MAX_HEIGHT.Value.ToString("G29"):""), OVERRIDE = s.OVERRIDE_AUTO_CALCULATION }).FirstOrDefault(); return(trimFormats); } }
/// <summary> /// Add a new pubisher group /// </summary> /// <param name="groupID"></param> /// <param name="PUBLISHER_ID"></param> /// <returns></returns> public bool AddGroupPublishers(long groupID, long PUBLISHER_ID) { try { using (SGGSEntities context = new SGGSEntities()) { var group = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == groupID && x.PUBLISHER_ID == PUBLISHER_ID).FirstOrDefault(); if (group == null) { SGGS_GROUP_PUBLISHER newGroup = new SGGS_GROUP_PUBLISHER(); newGroup.PUBLISHER_ID = PUBLISHER_ID; newGroup.GROUP_ID = groupID; newGroup.DATE_ADDED = DateTime.Now; newGroup.DATE_UPDATED = DateTime.Now; context.SGGS_GROUP_PUBLISHER.AddObject(newGroup); context.SaveChanges(); return(true); } return(false); } } catch { return(false); } }
/// <summary> /// Get Publisher group by group Id /// </summary> /// <param name="GROUP_ID"></param> /// <returns></returns> public DataTable GetGroupPublishers(long GROUP_ID) { try { using (SGGSEntities context = new SGGSEntities()) { List <string> publisherIds = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == GROUP_ID).Select(s => s.PUBLISHER_ID.ToString()).ToList(); var result = (from p in context.SGGS_PUBLISHER where publisherIds.Contains(p.PUBLISHER_ID.ToString()) select p).AsEnumerable() .Select(s => new { s.PUBLISHER_ID, PUBLISHER_NAME = s.PUBLISHER_NUMBER + "-" + s.PUBLISHER_NAME }).ToList(); return(CommonUtils.ToDataTable(result)); } } catch { return(null); } }
/// <summary> /// Method to Delete Record by SuptrimformatID /// </summary> /// <param name="suppTrimFormatID"></param> /// <returns></returns> public bool DeleteSupportTrimFormat(long suppTrimFormatID) { using (var context = new SGGSEntities()) { var suppTrim = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == suppTrimFormatID); context.SGGS_SUPPORTED_TRIM_FORMATS.DeleteObject(suppTrim); context.SaveChanges(); return(true); } }
/// <summary> /// Method to Delete Record /// </summary> /// <returns></returns> public bool Delete() { using (var context = new SGGSEntities()) { var trim = context.SGGS_CODE_TRIM_FORMAT.FirstOrDefault(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID); context.SGGS_CODE_TRIM_FORMAT.DeleteObject(trim); context.SaveChanges(); return(true); } }
/// <summary> /// Method to Delete Record /// </summary> /// <returns></returns> public Boolean Delete() { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == GROUP_ID).FirstOrDefault(); context.SGGS_GROUP.DeleteObject(group); context.SaveChanges(); return(true); } }
/// <summary> /// Static method to get GroupCode for a specified groupID /// </summary> /// <param name="db"></param> /// <param name="groupCode"></param> /// <returns></returns> public static string GetGroupCode(long groupID) { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP publisher = context.SGGS_GROUP.Where(x => x.GROUP_ID == groupID).FirstOrDefault(); if (publisher != null) { return(publisher.GROUP_CODE); } return(string.Empty); } }
/// <summary> /// Method to update a record /// </summary> /// <returns></returns> public Boolean Save() { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == GROUP_ID).FirstOrDefault(); group.DATE_UPDATED = DateTime.Now; group.DEFAULT_PUBLISHER_NUMBER = DEFAULT_PUBLISHER_NUMBER; group.GROUP_CODE = GROUP_CODE; group.GROUP_DESCRIPTION = GROUP_DESCRIPTION; group.GROUP_NAME = GROUP_NAME; context.SaveChanges(); return(true); } }
/// <summary> /// Add Duplicate Supported TrimFormat /// </summary> /// <param name="oldPrintPlantProfileId"></param> /// <param name="newPrintPlantProfile"></param> public void DuplicateSupportedTrimFormat(long oldPrintPlantProfileId, long newPrintPlantProfile) { using (var context = new SGGSEntities()) { var supportedTrimFormats = (from tf in context.SGGS_SUPPORTED_TRIM_FORMATS join pt in context.SGGS_SUPPORTED_PAPER_TYPE on tf.SUPPORTED_PAPER_TYPE_ID equals pt.SUPPORTED_PAPER_TYPE_ID join bt in context.SGGS_SUPPORTED_BIND_TYPE on tf.SUPPORTED_BIND_TYPE_ID equals bt.SUPPORTED_BIND_TYPE_ID where tf.PRINT_PLANT_PROFILE_ID == oldPrintPlantProfileId select new TrimFormat { SUPPORTED_PAPER_TYPE = tf.SUPPORTED_PAPER_TYPE_ID, SUPPORTED_BINDING_TYPE = tf.SUPPORTED_BIND_TYPE_ID, PAPER_TYPE_ID = pt.PAPER_TYPE_ID, BINDING_TYPE_ID = bt.BINDING_TYPE_ID, PRINT_PLANT_PROFILE_ID = tf.PRINT_PLANT_PROFILE_ID, TRIM_FORMAT_ID = tf.TRIM_FORMAT_ID, MAX_PAGES = tf.TEXT_PAGE_COUNT_MAX, MIN_PAGES = tf.TEXT_PAGE_COUNT_MIN, TRIM_FORMAT_MIN_WIDTH = tf.TRIM_FORMAT_MIN_WIDTH, TRIM_FORMAT_MAX_WIDTH = tf.TRIM_FORMAT_MAX_WIDTH, TRIM_FORMAT_MAX_HEIGHT = tf.TRIM_FORMAT_MAX_HEIGHT, TRIM_FORMAT_MIN_HEIGHT = tf.TRIM_FORMAT_MIN_HEIGHT, OVERRIDE_AUTO_CALCULATION = tf.OVERRIDE_AUTO_CALCULATION, SUPPORTED_PRINT_QUALITY_ID = tf.SUPPORTED_PRINT_QUALITY }).ToList(); foreach (var item in supportedTrimFormats) { SUPPORTED_PAPER_TYPE = (from bt in context.SGGS_SUPPORTED_PAPER_TYPE where bt.PRINT_PLANT_PROFILE_ID == newPrintPlantProfile && bt.PAPER_TYPE_ID == item.PAPER_TYPE_ID select bt.SUPPORTED_PAPER_TYPE_ID).FirstOrDefault(); SUPPORTED_BINDING_TYPE = (from bt in context.SGGS_SUPPORTED_BIND_TYPE where bt.PRINT_PLANT_PROFILE_ID == newPrintPlantProfile && bt.BINDING_TYPE_ID == item.BINDING_TYPE_ID select bt.SUPPORTED_BIND_TYPE_ID).FirstOrDefault(); PRINT_PLANT_PROFILE_ID = newPrintPlantProfile; TRIM_FORMAT_ID = item.TRIM_FORMAT_ID; MAX_PAGES = item.MAX_PAGES; MIN_PAGES = item.MIN_PAGES; TRIM_FORMAT_MIN_WIDTH = item.TRIM_FORMAT_MIN_WIDTH; TRIM_FORMAT_MAX_WIDTH = item.TRIM_FORMAT_MAX_WIDTH; TRIM_FORMAT_MAX_HEIGHT = item.TRIM_FORMAT_MAX_HEIGHT; TRIM_FORMAT_MIN_HEIGHT = item.TRIM_FORMAT_MIN_HEIGHT; OVERRIDE_AUTO_CALCULATION = item.OVERRIDE_AUTO_CALCULATION; SUPPORTED_PRINT_QUALITY_ID = item.SUPPORTED_PRINT_QUALITY_ID; AddDuplicatedTrimFormats(); } } }
/// <summary> /// Remove a TrimFormat by trimFormatId /// </summary> /// <param name="trimFormatId"></param> /// <returns></returns> public string RemoveTrimFormat(long trimFormatId) { using (var context = new SGGSEntities()) { var trimFormat = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == trimFormatId); if (trimFormat == null) { return("notRemoved"); } context.SGGS_SUPPORTED_TRIM_FORMATS.DeleteObject(trimFormat); context.SaveChanges(); return("removed"); } }
/// <summary> /// Update a group publisher /// </summary> /// <param name="publisherNumber"></param> /// <param name="billToPublisherNumber"></param> /// <returns></returns> public bool UpdateGroupPublishers(string publisherNumber, string billToPublisherNumber) { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP group = context.SGGS_GROUP.Where(x => x.GROUP_ID == this.GROUP_ID).FirstOrDefault(); if (group != null) { group.DEFAULT_PUBLISHER_NUMBER = publisherNumber; group.DEFAULT_BILL_TO_PUBLISHER_NUMBER = billToPublisherNumber; context.SaveChanges(); return(true); } return(false); } }
/// <summary> /// To delete data that was duplicated /// </summary> /// <param name="printPlantProfileId">print plant profile identifier</param> public void DeleteDuplicatedSupportedTrimFormat(long printPlantProfileId) { using (var context = new SGGSEntities()) { var supportedTrimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS .Where(x => x.PRINT_PLANT_PROFILE_ID == printPlantProfileId) .Select(s => new { s.SUPPORTED_TRIM_FORMATS_ID }).ToList(); foreach (var item in supportedTrimFormats) { DeleteSupportTrimFormat(item.SUPPORTED_TRIM_FORMATS_ID); } } }
/// <summary> /// Method to insert record in Group Table /// </summary> /// <returns></returns> public Boolean Add() { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP group = new SGGS_GROUP(); group.DATE_ADDED = DateTime.Now; group.DATE_UPDATED = DateTime.Now; group.DEFAULT_PUBLISHER_NUMBER = DEFAULT_PUBLISHER_NUMBER; group.GROUP_CODE = GROUP_CODE; group.GROUP_DESCRIPTION = GROUP_DESCRIPTION; group.GROUP_NAME = GROUP_NAME; context.SGGS_GROUP.AddObject(group); context.SaveChanges(); GROUP_ID = group.GROUP_ID; return(true); } }
/// <summary> /// Delete a publisher group /// </summary> /// <param name="groupID"></param> /// <param name="publisherID"></param> /// <returns></returns> public bool DeleteGroupPublisher(long groupID, long publisherID) { try { using (SGGSEntities context = new SGGSEntities()) { SGGS_GROUP_PUBLISHER group = context.SGGS_GROUP_PUBLISHER.Where(x => x.GROUP_ID == groupID && x.PUBLISHER_ID == publisherID).FirstOrDefault(); context.SGGS_GROUP_PUBLISHER.DeleteObject(group); context.SaveChanges(); return(true); } } catch { return(false); } }
/// <summary> /// Get All groups by search criteria /// </summary> /// <param name="search"></param> /// <returns></returns> public DataTable GetAllGroups(string search) { try { using (SGGSEntities context = new SGGSEntities()) { if (!string.IsNullOrEmpty(search)) { var result = context.SGGS_GROUP.Where(x => x.GROUP_CODE.ToString().Contains(search) || x.GROUP_NAME.Contains(search) || x.DEFAULT_PUBLISHER_NUMBER.Contains(search)) .OrderBy(o => o.GROUP_CODE) .Select(s => new { s.DATE_ADDED, s.DATE_UPDATED, DEFAULT_PUBLISHER_NUMBER = context.SGGS_PUBLISHER.Where(x => x.PUBLISHER_NUMBER == s.DEFAULT_PUBLISHER_NUMBER).Select(n => new { Name = n.PUBLISHER_NUMBER + "-" + n.PUBLISHER_NAME }).FirstOrDefault().Name, s.GROUP_CODE, s.GROUP_DESCRIPTION, s.GROUP_ID, s.GROUP_NAME }).ToList(); return(CommonUtils.ToDataTable(result)); } else { var result = context.SGGS_GROUP.OrderBy(o => o.GROUP_CODE) .Select(s => new { s.DATE_ADDED, s.DATE_UPDATED, DEFAULT_PUBLISHER_NUMBER = context.SGGS_PUBLISHER.Where(x => x.PUBLISHER_NUMBER == s.DEFAULT_PUBLISHER_NUMBER).Select(n => new { Name = n.PUBLISHER_NUMBER + "-" + n.PUBLISHER_NAME }).FirstOrDefault().Name, s.GROUP_CODE, s.GROUP_DESCRIPTION, s.GROUP_ID, s.GROUP_NAME }).ToList(); return(CommonUtils.ToDataTable(result)); } } } catch { return(null); } }
/// <summary> /// Method to Load values from DB /// </summary> /// <param name="TRIM_FORMAT_ID"></param> /// <returns></returns> public bool Load(long TRIM_FORMAT_ID) { using (var context = new SGGSEntities()) { var result = context.SGGS_CODE_TRIM_FORMAT.Where(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID) .Select(s => new { s.DATE_ADDED, s.DATE_UPDATED, s.TRIM_FORMAT_HEIGHT_IN, s.TRIM_FORMAT_HEIGHT_MM, s.TRIM_FORMAT_ID, s.TRIM_FORMAT_NAME, s.TRIM_FORMAT_NUMBER, s.TRIM_FORMAT_WIDTH_IN, s.TRIM_FORMAT_WIDTH_MM, s.USAGE_HARDCOVER, s.USAGE_PAPERBACK, s.HARD_COVER, s.SOFT_COVER }).FirstOrDefault(); if (result != null) { this.DATE_ADDED = result.DATE_ADDED; this.DATE_UPDATED = result.DATE_UPDATED.Value; this.TRIM_FORMAT_HEIGHT_IN = result.TRIM_FORMAT_HEIGHT_IN; this.TRIM_FORMAT_HEIGHT_MM = result.TRIM_FORMAT_HEIGHT_MM; this.TRIM_FORMAT_ID = result.TRIM_FORMAT_ID; this.TRIM_FORMAT_NAME = result.TRIM_FORMAT_NAME; this.TRIM_FORMAT_NUMBER = result.TRIM_FORMAT_NUMBER; this.TRIM_FORMAT_WIDTH_IN = result.TRIM_FORMAT_WIDTH_IN; this.TRIM_FORMAT_WIDTH_MM = result.TRIM_FORMAT_WIDTH_MM; this.USAGE_HARDCOVER = result.USAGE_HARDCOVER; this.USAGE_PAPERBACK = result.USAGE_PAPERBACK; this.HARD_COVER = result.HARD_COVER ?? false; this.SOFT_COVER = result.SOFT_COVER ?? false; return(true); } return(false); } }
/// <summary> /// Method to insert record /// </summary> /// <returns></returns> public bool Save() { using (var context = new SGGSEntities()) { var trim = context.SGGS_CODE_TRIM_FORMAT.FirstOrDefault(x => x.TRIM_FORMAT_ID == TRIM_FORMAT_ID); trim.DATE_UPDATED = DateTime.Now; trim.TRIM_FORMAT_HEIGHT_IN = TRIM_FORMAT_HEIGHT_IN; trim.TRIM_FORMAT_HEIGHT_MM = TRIM_FORMAT_HEIGHT_MM; trim.TRIM_FORMAT_NAME = TRIM_FORMAT_NAME; trim.TRIM_FORMAT_NUMBER = TRIM_FORMAT_NUMBER; trim.TRIM_FORMAT_WIDTH_IN = TRIM_FORMAT_WIDTH_IN; trim.TRIM_FORMAT_WIDTH_MM = TRIM_FORMAT_WIDTH_MM; trim.USAGE_HARDCOVER = USAGE_HARDCOVER; trim.USAGE_PAPERBACK = USAGE_PAPERBACK; trim.SOFT_COVER = SOFT_COVER; trim.HARD_COVER = HARD_COVER; context.SaveChanges(); return(true); } }
/// <summary> /// GetGroupName: return group name using Group Code /// </summary> /// <param name="db"></param> /// <param name="groupCode"></param> /// <returns></returns> public static string GetGroupNameUsingGroupCode(string groupCode) { try { using (SGGSEntities context = new SGGSEntities()) { var result = context.SGGS_GROUP.Where(x => x.GROUP_CODE == groupCode).Select(s => new { s.GROUP_NAME }).FirstOrDefault(); if (result != null) { return(result.GROUP_NAME); } return("None"); } } catch { return("None"); } }
/// <summary> /// Get Group Default Bill To Publisher /// </summary> /// <param name="groupID"></param> /// <returns></returns> public static string GetGroupDefaultBillToPublisher(long groupID) { try { using (SGGSEntities context = new SGGSEntities()) { var result = context.SGGS_GROUP.Where(x => x.GROUP_ID == groupID).Select(s => new { s.DEFAULT_BILL_TO_PUBLISHER_NUMBER }).FirstOrDefault(); if (result != null) { return(result.DEFAULT_BILL_TO_PUBLISHER_NUMBER); } return(string.Empty); } } catch { return(string.Empty); } }
/// <summary> /// Get Paper Type and Print Quality Information /// </summary> /// <param name="suppPaperTypeID"></param> /// <param name="PrintQualityID"></param> /// <returns></returns> public dynamic GetPaperQualityInformation(long suppPaperTypeID, long PrintQualityID) { using (var context = new SGGSEntities()) { var paperQualityInformation = context.SGGS_SUPPORTED_PAPER_TYPE .Where(x => x.SUPPORTED_PAPER_TYPE_ID == suppPaperTypeID) .Select(s => new { PAPER_TYPE_NAME = (from p in context.SGGS_PAPER_TYPE where p.PAPER_TYPE_ID == s.PAPER_TYPE_ID select p.PAPER_NAME).FirstOrDefault(), PrintQuality = (from pq in context.SGGS_CODE_PRINT_QUALITY where pq.PRINT_QUALITY_ID == PrintQualityID select pq.PRINT_QUALITY_NAME).FirstOrDefault(), }).FirstOrDefault(); return(paperQualityInformation != null ? paperQualityInformation : null); } }
/// <summary> /// Method that adds new trim format to the print plant profile /// </summary> /// <param name="formats">New trim formats added</param> /// <returns></returns> public bool AddSupportedTrimFormats(IList <TrimFormat> formats, bool supportRanges) { if (formats.Count <= 0) { return(false); } using (var context = new SGGSEntities()) { foreach (var item in formats) { var sggsCodePrintQuality = context.SGGS_CODE_PRINT_QUALITY.FirstOrDefault(q => q.PRINT_QUALITY_NUMBER == item.SUPPORTED_PRINT_QUALITY); var trimFormat = new SGGS_SUPPORTED_TRIM_FORMATS { SUPPORTED_PAPER_TYPE_ID = item.SUPPORTED_PAPER_TYPE, SUPPORTED_BIND_TYPE_ID = item.SUPPORTED_BINDING_TYPE, PRINT_PLANT_PROFILE_ID = item.PRINT_PLANT_PROFILE_ID, TRIM_FORMAT_ID = item.TRIM_FORMAT_ID, TEXT_PAGE_COUNT_MAX = item.MAX_PAGES, TEXT_PAGE_COUNT_MIN = item.MIN_PAGES, TRIM_FORMAT_MAX_HEIGHT = item.TRIM_FORMAT_MAX_HEIGHT, TRIM_FORMAT_MIN_HEIGHT = item.TRIM_FORMAT_MIN_HEIGHT, TRIM_FORMAT_MIN_WIDTH = item.TRIM_FORMAT_MIN_WIDTH, TRIM_FORMAT_MAX_WIDTH = item.TRIM_FORMAT_MAX_WIDTH, OVERRIDE_AUTO_CALCULATION = item.OVERRIDE_AUTO_CALCULATION }; if (sggsCodePrintQuality != null) { trimFormat.SUPPORTED_PRINT_QUALITY = sggsCodePrintQuality.PRINT_QUALITY_ID; } if (!CheckTrimFormatIsValid(trimFormat, supportRanges)) { context.SGGS_SUPPORTED_TRIM_FORMATS.AddObject(trimFormat); } } context.SaveChanges(); return(true); } }
/// <summary> /// Method to Delete Record by SuptrimformatID /// </summary> /// <returns></returns> public DataTable GetTrimFormat() { using (var context = new SGGSEntities()) { var result = context.SGGS_CODE_TRIM_FORMAT .Select(s => new { s.TRIM_FORMAT_ID, s.TRIM_FORMAT_NAME, s.TRIM_FORMAT_NUMBER, s.TRIM_FORMAT_WIDTH_MM, s.TRIM_FORMAT_WIDTH_IN, s.TRIM_FORMAT_HEIGHT_MM, s.TRIM_FORMAT_HEIGHT_IN, USAGE_PAPERBACK = s.USAGE_PAPERBACK == true ? "Yes" : "No", USAGE_HARDCOVER = s.USAGE_HARDCOVER == true ? "Yes" : "No" }).ToList(); return(CommonUtils.ToDataTable(result, "TrimFormat")); } }
/// <summary> /// Get Trim format by printPlantProfileId /// </summary> /// <param name="printPlantProfileId"></param> /// <returns></returns> public DataTable GetTrimFormat(long printPlantProfileId) { using (var context = new SGGSEntities()) { var profile = (from ppp in context.SGGS_PRINT_PLANT_PROFILE where ppp.PRINT_PLANT_PROFILE_ID == printPlantProfileId select ppp).FirstOrDefault(); if (profile != null) { if (profile.COVER_TYPE.ToUpper().Equals("S")) { var result = context.SGGS_CODE_TRIM_FORMAT .Where(x => x.SOFT_COVER == true) .Select(s => new { s.TRIM_FORMAT_ID, TRIM_FORMAT_NAME = s.TRIM_FORMAT_NAME + " (" + ((double)s.TRIM_FORMAT_WIDTH_IN).ToString() + " x " + ((double)s.TRIM_FORMAT_HEIGHT_IN).ToString() + ")" }).OrderBy(tf => tf.TRIM_FORMAT_NAME).ToList(); return(CommonUtils.ToDataTable(result, "TrimFormat")); } if (profile.COVER_TYPE.ToUpper().Equals("H")) { var result = context.SGGS_CODE_TRIM_FORMAT .Where(x => x.HARD_COVER == true) .Select(s => new { s.TRIM_FORMAT_ID, TRIM_FORMAT_NAME = s.TRIM_FORMAT_NAME + " (" + ((double)s.TRIM_FORMAT_WIDTH_IN).ToString() + " x " + ((double)s.TRIM_FORMAT_HEIGHT_IN).ToString() + ")" }).OrderBy(tf => tf.TRIM_FORMAT_NAME).ToList(); return(CommonUtils.ToDataTable(result, "TrimFormat")); } return(null); } return(null); } }
/// <summary> /// Inserts or update a new book into sggs /// </summary> /// <param name="publisherNumber"></param> /// <param name="title"></param> /// <param name="subtitle"></param> /// <param name="isbn"></param> /// <param name="edition"></param> /// <param name="copyRightYear"></param> /// <returns></returns> public SGGS_BOOK InsertUpdateBook(string publisherNumber, string title, string subtitle, string isbn, string edition, string copyRightYear) { using (SGGSEntities objSGGS = new SGGSEntities()) { SGGS_BOOK sggsBook = new SGGS_BOOK(); SGGS_PUBLISHER sggsPublisher = new SGGS_PUBLISHER(); var publisher = objSGGS.SGGS_PUBLISHER.Where(P => P.PUBLISHER_NUMBER == publisherNumber).FirstOrDefault(); /////// if (publisher != null) { sggsBook = (from B in objSGGS.SGGS_BOOK where B.BOOK_NUMBER == isbn && B.PUBLISHER_ID == publisher.PUBLISHER_ID select B).SingleOrDefault(); if (sggsBook == null) { sggsBook = new SGGS_BOOK(); sggsBook.BOOK_TITLE = title; sggsBook.DATE_UPDATED = System.DateTime.Now; sggsBook.PUBLISHER_ID = publisher.PUBLISHER_ID; sggsBook.BOOK_IDENTIFICATION_TYPE = "ISBN"; sggsBook.BOOK_NUMBER = isbn; sggsBook.IS_ENABLED = true; sggsBook.IS_NEW = true; sggsBook.DATE_ADDED = System.DateTime.Now; objSGGS.SGGS_BOOK.AddObject(sggsBook); objSGGS.SaveChanges(); } else if (sggsBook != null) { sggsBook.BOOK_TITLE = title; sggsBook.DATE_UPDATED = System.DateTime.Now; objSGGS.SaveChanges(); } } return(sggsBook); } }
/// <summary> /// Edit Publisher group by Group ID /// </summary> /// <param name="GROUP_ID"></param> /// <returns></returns> public DataTable EditGroupPublishers(long GROUP_ID) { try { using (SGGSEntities context = new SGGSEntities()) { var result = (from p in context.SGGS_PUBLISHER select p).AsEnumerable() .Select(s => new { s.PUBLISHER_ID, PUBLISHER_NAME = s.PUBLISHER_NUMBER + "-" + s.PUBLISHER_NAME, s.PUBLISHER_NUMBER, IS_GROUP_PUBLISHER = context.SGGS_GROUP_PUBLISHER.Any(gp => gp.GROUP_ID == GROUP_ID && gp.PUBLISHER_ID == s.PUBLISHER_ID) }).OrderBy(o => o.PUBLISHER_NUMBER).ToList(); return(CommonUtils.ToDataTable(result)); } } catch { return(null); } }
/// <summary> /// Update TrimFormat Update /// </summary> /// <param name="supportedTrimFormatId"></param> /// <param name="minPages"></param> /// <param name="maxPages"></param> /// <param name="minWidth"></param> /// <param name="maxWidth"></param> /// <param name="minHeight"></param> /// <param name="maxHeight"></param> /// <param name="overriding"></param> /// <returns></returns> public string Update(long supportedTrimFormatId, int?minPages, int?maxPages, decimal?minWidth, decimal?maxWidth, decimal?minHeight, decimal?maxHeight, bool overriding) { using (var context = new SGGSEntities()) { var trimFormats = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == supportedTrimFormatId); if (trimFormats == null) { return("notSaved"); } trimFormats.TEXT_PAGE_COUNT_MIN = minPages; trimFormats.TEXT_PAGE_COUNT_MAX = maxPages; trimFormats.TRIM_FORMAT_MIN_WIDTH = minWidth; trimFormats.TRIM_FORMAT_MAX_WIDTH = maxWidth; trimFormats.TRIM_FORMAT_MIN_HEIGHT = minHeight; trimFormats.TRIM_FORMAT_MAX_HEIGHT = maxHeight; trimFormats.OVERRIDE_AUTO_CALCULATION = overriding; context.SaveChanges(); return("saved"); } }
/// <summary> /// Update TrimFormat /// </summary> /// <param name="supportedTrimFormatId"></param> /// <param name="minPages"></param> /// <param name="maxPages"></param> /// <param name="minWidth"></param> /// <param name="maxWidth"></param> /// <param name="minHeight"></param> /// <param name="maxHeight"></param> /// <param name="overriding"></param> /// <param name="supportRanges"></param> /// <returns></returns> public string UpdatingTrimFormat(long supportedTrimFormatId, string minPages, string maxPages, string minWidth, string maxWidth, string minHeight, string maxHeight, bool overriding, bool supportRanges) { using (var context = new SGGSEntities()) { SGGS_SUPPORTED_TRIM_FORMATS dataFound = null; var trimFormat = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(x => x.SUPPORTED_TRIM_FORMATS_ID == supportedTrimFormatId); if (trimFormat == null) { return("notExists"); } if (!supportRanges && overriding) { var maxP = Convert.ToInt32(maxPages); var minP = Convert.ToInt32(minPages); dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf => tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID && tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID && tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID && tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID && tf.TRIM_FORMAT_ID == trimFormat.TRIM_FORMAT_ID && tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY && tf.TEXT_PAGE_COUNT_MAX == maxP && tf.TEXT_PAGE_COUNT_MIN == minP && tf.TRIM_FORMAT_MIN_WIDTH == null && tf.TRIM_FORMAT_MAX_WIDTH == null && tf.TRIM_FORMAT_MIN_HEIGHT == null && tf.TRIM_FORMAT_MAX_HEIGHT == null && tf.OVERRIDE_AUTO_CALCULATION == overriding); if (dataFound == null) { return(Update(supportedTrimFormatId, Convert.ToInt32(minPages), Convert.ToInt32(maxPages), null, null, null, null, overriding)); } } else if (!supportRanges && !overriding) { dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf => tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID && tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID && tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID && tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID && tf.TRIM_FORMAT_ID == trimFormat.TRIM_FORMAT_ID && tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY && tf.TEXT_PAGE_COUNT_MAX == null && tf.TEXT_PAGE_COUNT_MIN == null && tf.TRIM_FORMAT_MIN_WIDTH == null && tf.TRIM_FORMAT_MAX_WIDTH == null && tf.TRIM_FORMAT_MIN_HEIGHT == null && tf.TRIM_FORMAT_MAX_HEIGHT == null && tf.OVERRIDE_AUTO_CALCULATION == overriding); if (dataFound == null) { return(Update(supportedTrimFormatId, null, null, null, null, null, null, overriding)); } } else if (supportRanges && !overriding) { var maxW = Math.Round(Convert.ToDecimal(maxWidth), 5); var minW = Math.Round(Convert.ToDecimal(minWidth), 5); var minH = Math.Round(Convert.ToDecimal(minHeight), 5); var maxH = Math.Round(Convert.ToDecimal(maxHeight), 5); dataFound = context.SGGS_SUPPORTED_TRIM_FORMATS.FirstOrDefault(tf => tf.SUPPORTED_TRIM_FORMATS_ID != trimFormat.SUPPORTED_TRIM_FORMATS_ID && tf.PRINT_PLANT_PROFILE_ID == trimFormat.PRINT_PLANT_PROFILE_ID && tf.SUPPORTED_PAPER_TYPE_ID == trimFormat.SUPPORTED_PAPER_TYPE_ID && tf.SUPPORTED_BIND_TYPE_ID == trimFormat.SUPPORTED_BIND_TYPE_ID && tf.TRIM_FORMAT_ID == null && tf.SUPPORTED_PRINT_QUALITY == trimFormat.SUPPORTED_PRINT_QUALITY && tf.TEXT_PAGE_COUNT_MAX == null && tf.TEXT_PAGE_COUNT_MIN == null && tf.TRIM_FORMAT_MIN_WIDTH == minW && tf.TRIM_FORMAT_MAX_WIDTH == maxW && tf.TRIM_FORMAT_MIN_HEIGHT == minH && tf.TRIM_FORMAT_MAX_HEIGHT == maxH && tf.OVERRIDE_AUTO_CALCULATION == overriding); if (dataFound == null) { return(Update(supportedTrimFormatId, null, null, Math.Round(Convert.ToDecimal(minWidth), 5), Math.Round(Convert.ToDecimal(maxWidth), 5), Math.Round(Convert.ToDecimal(minHeight), 5), Math.Round(Convert.ToDecimal(maxHeight), 5), overriding)); } } return(dataFound != null ? "exists" : string.Empty); } }