public long UpdateStructure(StructureObject structure) { try { if (structure == null) { return(-2); } var structureEntity = ModelMapper.Map <StructureObject, Structure>(structure); if (structureEntity == null || structureEntity.StructureId < 1) { return(-2); } using (var db = new ImportPermitEntities()) { db.Structures.Attach(structureEntity); db.Entry(structureEntity).State = EntityState.Modified; db.SaveChanges(); return(structure.StructureId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public List <AccountTypeObject> GetAccountTypes() { try { using (var db = new ImportPermitEntities()) { var accountTypes = db.AccountTypes.ToList(); if (!accountTypes.Any()) { return(new List <AccountTypeObject>()); } var objList = new List <AccountTypeObject>(); accountTypes.ForEach(app => { var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app); if (accountTypeObject != null && accountTypeObject.AccountTypeId > 0) { objList.Add(accountTypeObject); } }); return(!objList.Any() ? new List <AccountTypeObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public ProductColumnObject GetProductColumn(long productColumnId) { try { using (var db = new ImportPermitEntities()) { var productColumns = db.ProductColumns.Where(m => m.ProductColumnId == productColumnId) .Include("CustomCode") .Include("Product") .ToList(); if (!productColumns.Any()) { return(new ProductColumnObject()); } var app = productColumns[0]; var productColumnObject = ModelMapper.Map <ProductColumn, ProductColumnObject>(app); if (productColumnObject == null || productColumnObject.ProductColumnId < 1) { return(new ProductColumnObject()); } productColumnObject.ProductName = app.Product.Name; productColumnObject.CustomCodeName = app.CustomCode.Name; return(productColumnObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new ProductColumnObject()); } }
public AccountTypeObject GetAccountType(long accountTypeId) { try { using (var db = new ImportPermitEntities()) { var accountTypes = db.AccountTypes.Where(m => m.AccountTypeId == accountTypeId) .ToList(); if (!accountTypes.Any()) { return(new AccountTypeObject()); } var app = accountTypes[0]; var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app); if (accountTypeObject == null || accountTypeObject.AccountTypeId < 1) { return(new AccountTypeObject()); } return(accountTypeObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new AccountTypeObject()); } }
public List <AccountTypeObject> Search(string searchCriteria) { try { using (var db = new ImportPermitEntities()) { var accountTypes = db.AccountTypes.Where(m => m.Name.ToLower().Trim() == searchCriteria.ToLower().Trim()) .ToList(); if (accountTypes.Any()) { var newList = new List <AccountTypeObject>(); accountTypes.ForEach(app => { var accountTypeObject = ModelMapper.Map <AccountType, AccountTypeObject>(app); if (accountTypeObject != null && accountTypeObject.AccountTypeId > 0) { newList.Add(accountTypeObject); } }); return(newList); } } return(new List <AccountTypeObject>()); } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new List <AccountTypeObject>()); } }
public CustomCodeObject GetCustomCode(long customCodeId) { try { using (var db = new ImportPermitEntities()) { var customCodes = db.CustomCodes.Where(m => m.CustomCodeId == customCodeId) .ToList(); if (!customCodes.Any()) { return(new CustomCodeObject()); } var app = customCodes[0]; var customCodeObject = ModelMapper.Map <CustomCode, CustomCodeObject>(app); if (customCodeObject == null || customCodeObject.CustomCodeId < 1) { return(new CustomCodeObject()); } return(customCodeObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new CustomCodeObject()); } }
public List <CustomCodeObject> GetCustomCodes() { try { using (var db = new ImportPermitEntities()) { var customCodes = db.CustomCodes.ToList(); if (!customCodes.Any()) { return(new List <CustomCodeObject>()); } var objList = new List <CustomCodeObject>(); customCodes.ForEach(app => { var customCodeObject = ModelMapper.Map <CustomCode, CustomCodeObject>(app); if (customCodeObject != null && customCodeObject.CustomCodeId > 0) { objList.Add(customCodeObject); } }); return(!objList.Any() ? new List <CustomCodeObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public List <ImportClassObject> GetImportClasses() { try { using (var db = new ImportPermitEntities()) { var importClasss = db.ImportClasses.OrderBy(m => m.Name).ToList(); if (!importClasss.Any()) { return(new List <ImportClassObject>()); } var objList = new List <ImportClassObject>(); importClasss.ForEach(app => { var importClassObject = ModelMapper.Map <ImportClass, ImportClassObject>(app); if (importClassObject != null && importClassObject.Id > 0) { objList.Add(importClassObject); } }); return(!objList.Any() ? new List <ImportClassObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public long AddSignDocument(SignOffDocumentObject document) { try { if (document == null) { return(-2); } var documentEntity = ModelMapper.Map <SignOffDocumentObject, SignOffDocument>(document); if (documentEntity == null || string.IsNullOrEmpty(documentEntity.DocumentPath) || documentEntity.ApplicationId < 1) { return(-2); } using (var db = new ImportPermitEntities()) { var imApp = db.SignOffDocuments.Add(documentEntity); db.SaveChanges(); return(imApp.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public ImportClassObject GetImportClass(long importClassId) { try { using (var db = new ImportPermitEntities()) { var importClasss = db.ImportClasses.Where(m => m.Id == importClassId) .ToList(); if (!importClasss.Any()) { return(new ImportClassObject()); } var app = importClasss[0]; var importClassObject = ModelMapper.Map <ImportClass, ImportClassObject>(app); if (importClassObject == null || importClassObject.Id < 1) { return(new ImportClassObject()); } return(importClassObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new ImportClassObject()); } }
public long UpdateImportClass(ImportClassObject importClass) { try { if (importClass == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.ImportClasses.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == importClass.Name.ToLower().Trim().Replace(" ", "") && g.Id != importClass.Id) > 0) { return(-3); } var importClassEntity = ModelMapper.Map <ImportClassObject, ImportClass>(importClass); if (importClassEntity == null || importClassEntity.Id < 1) { return(-2); } db.ImportClasses.Attach(importClassEntity); db.Entry(importClassEntity).State = EntityState.Modified; db.SaveChanges(); return(importClass.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long AddImportClass(ImportClassObject importClass) { try { if (importClass == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.ImportClasses.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == importClass.Name.ToLower().Trim().Replace(" ", "")) > 0) { return(-3); } var importClassEntity = ModelMapper.Map <ImportClassObject, ImportClass>(importClass); if (importClassEntity == null || string.IsNullOrEmpty(importClassEntity.Name)) { return(-2); } var returnStatus = db.ImportClasses.Add(importClassEntity); db.SaveChanges(); return(returnStatus.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long AddImportStage(ImportStageObject importStage) { try { if (importStage == null) { return(-2); } var importStageEntity = ModelMapper.Map <ImportStageObject, ImportStage>(importStage); if (importStageEntity == null || string.IsNullOrEmpty(importStageEntity.Name)) { return(-2); } using (var db = new ImportPermitEntities()) { var returnStatus = db.ImportStages.Add(importStageEntity); db.SaveChanges(); return(returnStatus.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public List <StructureObject> GetStructures() { try { using (var db = new ImportPermitEntities()) { var structures = db.Structures.ToList(); if (!structures.Any()) { return(new List <StructureObject>()); } var objList = new List <StructureObject>(); structures.ForEach(app => { var structureObject = ModelMapper.Map <Structure, StructureObject>(app); if (structureObject != null && structureObject.StructureId > 0) { objList.Add(structureObject); } }); return(!objList.Any() ? new List <StructureObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public List <IssueLogObject> GetIssueLogs() { try { using (var db = new ImportPermitEntities()) { var issueLogObjects = db.IssueLogs.ToList(); if (!issueLogObjects.Any()) { return(new List <IssueLogObject>()); } var objList = new List <IssueLogObject>(); issueLogObjects.ForEach(app => { var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app); if (issueLogObjectObject != null && issueLogObjectObject.Id > 0) { objList.Add(issueLogObjectObject); } }); return(!objList.Any() ? new List <IssueLogObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public long UpdateDocument(DocumentObject document) { try { if (document == null) { return(-2); } var documentEntity = ModelMapper.Map <DocumentObject, Document>(document); if (documentEntity == null || documentEntity.DocumentId < 1) { return(-2); } using (var db = new ImportPermitEntities()) { db.Documents.Attach(documentEntity); db.Entry(documentEntity).State = EntityState.Modified; db.SaveChanges(); return(document.DocumentId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long AddCustomCode(CustomCodeObject customCode) { try { if (customCode == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.CustomCodes.Count(k => k.Name.ToLower().Trim() == customCode.Name.ToLower().Trim()) > 0) { return(-3); } var customCodeEntity = ModelMapper.Map <CustomCodeObject, CustomCode>(customCode); if (customCodeEntity == null || string.IsNullOrEmpty(customCodeEntity.Name)) { return(-2); } var returnStatus = db.CustomCodes.Add(customCodeEntity); db.SaveChanges(); return(returnStatus.CustomCodeId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long UpdateBankerDocument(DocumentObject document) { try { if (document == null) { return(-2); } using (var db = new ImportPermitEntities()) { var documentEntities = db.Documents.Where(d => d.DocumentId == document.DocumentId).ToList(); if (!documentEntities.Any()) { return(-2); } var documentEntity = documentEntities[0]; documentEntity.DateUploaded = document.DateUploaded; documentEntity.UploadedById = document.UploadedById; documentEntity.DocumentPath = document.DocumentPath; db.Entry(documentEntity).State = EntityState.Modified; db.SaveChanges(); return(documentEntity.DocumentId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long UpdateCustomCode(CustomCodeObject customCode) { try { if (customCode == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.CustomCodes.Count(k => k.Name.ToLower().Trim() == customCode.Name.ToLower().Trim() && k.CustomCodeId == customCode.CustomCodeId) > 0) { return(-3); } var customCodeEntity = ModelMapper.Map <CustomCodeObject, CustomCode>(customCode); if (customCodeEntity == null || customCodeEntity.CustomCodeId < 1) { return(-2); } db.CustomCodes.Attach(customCodeEntity); db.Entry(customCodeEntity).State = EntityState.Modified; db.SaveChanges(); return(customCode.CustomCodeId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public List <DocumentObject> GetDocuments() { try { using (var db = new ImportPermitEntities()) { var documents = db.Documents.ToList(); if (!documents.Any()) { return(new List <DocumentObject>()); } var objList = new List <DocumentObject>(); documents.ForEach(app => { var documentObject = ModelMapper.Map <Document, DocumentObject>(app); if (documentObject != null && documentObject.DocumentId > 0) { objList.Add(documentObject); } }); return(!objList.Any() ? new List <DocumentObject>() : objList); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(null); } }
public long AddAccountType(AccountTypeObject accountType) { try { if (accountType == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.AccountTypes.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == accountType.Name.ToLower().Trim().Replace(" ", "")) > 0) { return(-3); } var accountTypeEntity = ModelMapper.Map <AccountTypeObject, AccountType>(accountType); if (accountTypeEntity == null || string.IsNullOrEmpty(accountTypeEntity.Name)) { return(-2); } var returnStatus = db.AccountTypes.Add(accountTypeEntity); db.SaveChanges(); return(returnStatus.AccountTypeId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long AddIssueLog(IssueLogObject issueLogObject) { try { if (issueLogObject == null || issueLogObject.IssueCategoryId < 1) { return(-2); } var issueLogEntity = ModelMapper.Map <IssueLogObject, IssueLog>(issueLogObject); if (issueLogEntity == null || issueLogEntity.IssueCategoryId < 1) { return(-2); } using (var db = new ImportPermitEntities()) { var processedLog = db.IssueLogs.Add(issueLogEntity); db.SaveChanges(); return(processedLog.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public UserProfileObject GetUser(string id) { try { using (var db = new ImportPermitEntities()) { var users = db.AspNetUsers.Where(m => m.Id == id).Include("UserProfile") .ToList(); if (!users.Any()) { return(new UserProfileObject()); } var appUser = users[0].UserProfile; var userObject = ModelMapper.Map <UserProfile, UserProfileObject>(appUser); if (userObject == null || userObject.Id < 1) { return(new UserProfileObject()); } return(userObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new UserProfileObject()); } }
public IssueLogObject GetIssueLog(long issueLogObjectId) { try { using (var db = new ImportPermitEntities()) { var issueLogObjects = db.IssueLogs.Where(m => m.Id == issueLogObjectId) .ToList(); if (!issueLogObjects.Any()) { return(new IssueLogObject()); } var app = issueLogObjects[0]; var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app); if (issueLogObjectObject == null || issueLogObjectObject.Id < 1) { return(new IssueLogObject()); } return(issueLogObjectObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new IssueLogObject()); } }
public long UpdateAccountType(AccountTypeObject accountType) { try { if (accountType == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.AccountTypes.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == accountType.Name.ToLower().Trim().Replace(" ", "") && g.AccountTypeId != accountType.AccountTypeId) > 0) { return(-3); } var accountTypeEntity = ModelMapper.Map <AccountTypeObject, AccountType>(accountType); if (accountTypeEntity == null || accountTypeEntity.AccountTypeId < 1) { return(-2); } db.AccountTypes.Attach(accountTypeEntity); db.Entry(accountTypeEntity).State = EntityState.Modified; db.SaveChanges(); return(accountType.AccountTypeId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public List <IssueLogObject> Search(string searchCriteria) { try { using (var db = new ImportPermitEntities()) { var issueLogObjects = db.IssueLogs.Where(m => m.IssueCategory.Name.ToLower().Trim() == searchCriteria.ToLower().Trim()) .ToList(); if (issueLogObjects.Any()) { var newList = new List <IssueLogObject>(); issueLogObjects.ForEach(app => { var issueLogObjectObject = ModelMapper.Map <IssueLog, IssueLogObject>(app); if (issueLogObjectObject != null && issueLogObjectObject.Id > 0) { newList.Add(issueLogObjectObject); } }); return(newList); } } return(new List <IssueLogObject>()); } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new List <IssueLogObject>()); } }
public long AddProductColumn(ProductColumnObject productColumn) { try { if (productColumn == null) { return(-2); } using (var db = new ImportPermitEntities()) { if (db.ProductColumns.Count(k => k.CustomCodeId == productColumn.CustomCodeId && k.ProductId == productColumn.ProductId) > 0) { return(-3); } var productColumnEntity = ModelMapper.Map <ProductColumnObject, ProductColumn>(productColumn); if (productColumnEntity == null || productColumnEntity.ProductId < 1 || productColumnEntity.CustomCodeId < 1) { return(-2); } var returnStatus = db.ProductColumns.Add(productColumnEntity); db.SaveChanges(); return(returnStatus.ProductColumnId); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long UpdateIssueLog(IssueLogObject issueLogObject) { try { if (issueLogObject == null) { return(-2); } var issueLogEntity = ModelMapper.Map <IssueLogObject, IssueLog>(issueLogObject); if (issueLogEntity == null || issueLogEntity.Id < 1) { return(-2); } using (var db = new ImportPermitEntities()) { db.IssueLogs.Attach(issueLogEntity); db.Entry(issueLogEntity).State = EntityState.Modified; db.SaveChanges(); return(issueLogObject.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long DeleteProductColumn(long productColumnId) { try { using (var db = new ImportPermitEntities()) { var myItems = db.ProductColumns.Where(m => m.ProductColumnId == productColumnId).ToList(); if (!myItems.Any()) { return(0); } var item = myItems[0]; db.ProductColumns.Remove(item); db.SaveChanges(); return(5); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public StructureObject GetStructure(long structureId) { try { using (var db = new ImportPermitEntities()) { var structures = db.Structures.Where(m => m.StructureId == structureId) .ToList(); if (!structures.Any()) { return(new StructureObject()); } var app = structures[0]; var structureObject = ModelMapper.Map <Structure, StructureObject>(app); if (structureObject == null || structureObject.StructureId < 1) { return(new StructureObject()); } return(structureObject); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(new StructureObject()); } }