public void CreateNewBank(string bankCode, string bankName, string createdBy)
{
try
{
using (var unitOfWork = unitOfWorkManager.NewUnitOfWork())
{
try
{
var bank = new Bank(bankCode, bankName, null, false, createdBy, DateTime.Now, null, null);
bankRepository.Add(bank);
unitOfWork.Commit();
}
catch (Exception)
{
unitOfWork.Rollback();
throw;
}
}
}
catch (DbEntityValidationException dbEx)
{
var sb = new StringBuilder();
foreach (var validationError in dbEx.EntityValidationErrors.SelectMany(entityValidationErrors => entityValidationErrors.ValidationErrors))
{
sb.Append("Property: " + validationError.PropertyName + " Error: " + validationError.ErrorMessage);
}
throw new Exception(sb.ToString());
}
}
public IHttpActionResult Put(Guid key, DebtNoteViewModel delta)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (var unitOfWork = _unitOfWorkManager.NewUnitOfWork())
{
_debtNote.UpdateDebtNote(delta);
unitOfWork.Commit();
return(StatusCode(HttpStatusCode.OK));
}
}
public IHttpActionResult ScrapWar(string warName)
{
var catId = new Guid("B021A3BE-02C9-46B6-BCC8-A53900AB0A6A");
var category = _categoryService.Get(catId);
using (var unitOfWork = _unitOfWorkManager.NewUnitOfWork())
{
_topicService.GetAll().Where(t => t.Category == category && t.Name == warName).ToList().ForEach(t =>
t.Solved = true
);
// Save the changes
unitOfWork.SaveChanges();
unitOfWork.Commit();
}
return(Ok());
}
public BaseController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, IRoleService roleService, ISettingsService settingsService)
{
UnitOfWorkManager = unitOfWorkManager;
MembershipService = membershipService;
RoleService = roleService;
SettingsService = settingsService;
LoggingService = loggingService;
using (UnitOfWorkManager.NewUnitOfWork())
{
LoggedOnReadOnlyUser = UserIsAuthenticated ? MembershipService.GetUserByEmail(Email, true) : null;
UsersRole = LoggedOnReadOnlyUser == null?RoleService.GetRole(AppConstants.GuestRoleName, true) : LoggedOnReadOnlyUser.Roles.FirstOrDefault();
}
}
public void Execute(IJobExecutionContext context)
{
using (_unitOfWorkManager.NewUnitOfWork())
{
try
{
var url = _settingsService.GetSettings(false).ForumUrl;
AppHelpers.Ping(url);
}
catch (Exception ex)
{
_loggingService.Error(string.Concat("Error in KeepAlive job > ", ex.Message));
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="loggingService"> </param>
/// <param name="unitOfWorkManager"> </param>
/// <param name="membershipService"></param>
/// <param name="localizationService"> </param>
/// <param name="roleService"> </param>
/// <param name="settingsService"> </param>
public BaseController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService)
{
UnitOfWorkManager = unitOfWorkManager;
MembershipService = membershipService;
LocalizationService = localizationService;
RoleService = roleService;
SettingsService = settingsService;
LoggingService = loggingService;
using (UnitOfWorkManager.NewUnitOfWork())
{
LoggedOnReadOnlyUser = UserIsAuthenticated ? MembershipService.GetUser(Username, true) : null;
UsersRole = LoggedOnReadOnlyUser == null ? RoleService.GetRole(AppConstants.GuestRoleName, true) : LoggedOnReadOnlyUser.Roles.FirstOrDefault();
}
}
private bool IsAllowed(IWorkContext workContext, string controller)
{
//IUnitOfWorkManager unitOfWorkManager = DependencyResolver.Current.GetService<IUnitOfWorkManager>();
IUnitOfWorkManager unitOfWorkManager = IoCManager.Container.GetInstance <IUnitOfWorkManager>();
using (unitOfWorkManager.NewUnitOfWork())
{
var user = workContext.CurrentMembershipUser;
foreach (var role in user.MembershipRoles)
{
if (role.MenuItems.FirstOrDefault(x => x.Controllor != null && x.Controllor.ToLower() == controller.ToLower()) != null)
{
return(true);
}
}
}
return(false);
}
public void Execute(IJobExecutionContext context)
{
using (var unitOfWork = _unitOfWorkManager.NewUnitOfWork())
{
try
{
// Process emails to send - Only send the amount per job from the siteconstants
_emailService.ProcessMail(5);
// Commit - Which deletes the jobs that have been sent
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
_loggingService.Error(ex);
}
}
}
private void SetPageMenuItems()
{
_cachedPageMenuItems = new List <MenuItemWithChildren>();
using (_unitOfWorkManager.NewUnitOfWork())
{
var roles = CurrentMembershipUser.MembershipRoles;
foreach (var role in roles)
{
var mis = role.MenuItems.Where(x => x.ParentId == 0).ToList();
foreach (var menu in mis)
{
if (!_cachedPageMenuItems.Any(x => x.MenuItem.Id == menu.Id))
{
var mwc = new MenuItemWithChildren();
mwc.MenuItem = menu;
mwc.SubMenuItems = role.MenuItems.Where(x => x.ParentId == menu.Id)
.OrderBy(x => x.MenuOrder)
.ToList();
_cachedPageMenuItems.Add(mwc);
}
else
{
var rootNode = _cachedPageMenuItems.SingleOrDefault(x => x.MenuItem.Id == menu.Id);
var nodeOfRoles = role.MenuItems.Where(x => x.ParentId == menu.Id).ToList();
foreach (var item in nodeOfRoles)
{
if (!rootNode.SubMenuItems.Any(x => x.Id == item.Id))
{
rootNode.SubMenuItems.Add(item);
}
}
}
}
}
_cachedPageMenuItems = _cachedPageMenuItems.OrderBy(x => x.MenuItem.MenuOrder).ToList();
}
}
private InstallerResult CreateInitialData()
{
var installerResult = new InstallerResult {
Successful = true, Message = "Congratulations, MVC Forum has installed successfully"
};
// I think this is all I need to call to kick EF into life
//EFCachingProviderConfiguration.DefaultCache = new AspNetCache();
//EFCachingProviderConfiguration.DefaultCachingPolicy = CachingPolicy.CacheAll;
// Now setup the services as we can't do it in the constructor
InitialiseServices();
// First UOW to create the data needed for other saves
using (var unitOfWork = _UnitOfWorkManager.NewUnitOfWork())
{
try
{
// Check if category exists or not, we only do a single check for the first object within this
// UOW because, if anything failed inside. Everything else would be rolled back to because of the
// transaction
const string exampleCatName = "Example Category";
if (_categoryService.GetAll().FirstOrDefault(x => x.Name == exampleCatName) == null)
{
// Doesn't exist so add the example category
var exampleCat = new Category {
Name = exampleCatName, ModeratePosts = false, ModerateTopics = false
};
_categoryService.Add(exampleCat);
// Add the default roles
var standardRole = new MembershipRole {
RoleName = AppConstants.StandardMembers
};
var guestRole = new MembershipRole {
RoleName = AppConstants.GuestRoleName
};
var adminRole = new MembershipRole {
RoleName = AppConstants.AdminRoleName
};
_roleService.CreateRole(standardRole);
_roleService.CreateRole(guestRole);
_roleService.CreateRole(adminRole);
unitOfWork.Commit();
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
installerResult.Exception = ex.InnerException;
installerResult.Message = "Error creating the initial data >> Category & Roles";
installerResult.Successful = false;
return(installerResult);
}
}
// Add / Update the default language strings
installerResult = AddOrUpdateTheDefaultLanguageStrings(installerResult);
if (!installerResult.Successful)
{
return(installerResult);
}
// Now we have saved the above we can create the rest of the data
using (var unitOfWork = _UnitOfWorkManager.NewUnitOfWork())
{
try
{
// if the settings already exist then do nothing
if (_settingsService.GetSettings(false) == null)
{
// Get the default language
var startingLanguage = _localizationService.GetLanguageByName("en-GB");
// Get the Standard Members role
var startingRole = _roleService.GetRole(AppConstants.StandardMembers);
// create the settings
var settings = new Settings
{
ForumName = "MVC Forum",
ForumUrl = "http://www.mydomain.com",
IsClosed = false,
EnableRSSFeeds = true,
DisplayEditedBy = true,
EnablePostFileAttachments = false,
EnableMarkAsSolution = true,
EnableSpamReporting = true,
EnableMemberReporting = true,
EnableEmailSubscriptions = true,
ManuallyAuthoriseNewMembers = false,
EmailAdminOnNewMemberSignUp = true,
TopicsPerPage = 20,
PostsPerPage = 20,
EnablePrivateMessages = true,
MaxPrivateMessagesPerMember = 50,
PrivateMessageFloodControl = 1,
EnableSignatures = false,
EnablePoints = true,
PointsAllowedToVoteAmount = 1,
PointsAddedPerPost = 1,
PointsAddedForSolution = 4,
PointsDeductedNagativeVote = 2,
AdminEmailAddress = "*****@*****.**",
NotificationReplyEmail = "*****@*****.**",
SMTPEnableSSL = false,
Theme = "Metro",
NewMemberStartingRole = startingRole,
DefaultLanguage = startingLanguage,
ActivitiesPerPage = 20,
EnableAkisment = false,
EnableSocialLogins = false,
EnablePolls = true
};
_settingsService.Add(settings);
unitOfWork.Commit();
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
installerResult.Exception = ex.InnerException;
installerResult.Message = "Error creating the initial data >> Settings";
installerResult.Successful = false;
return(installerResult);
}
}
// Now we have saved the above we can create the rest of the data
using (var unitOfWork = _UnitOfWorkManager.NewUnitOfWork())
{
try
{
// If the admin user exists then don't do anything else
if (_membershipService.GetUser("admin") == null)
{
// Set up the initial category permissions
var readOnly = new Permission {
Name = AppConstants.PermissionReadOnly
};
var deletePosts = new Permission {
Name = AppConstants.PermissionDeletePosts
};
var editPosts = new Permission {
Name = AppConstants.PermissionEditPosts
};
var stickyTopics = new Permission {
Name = AppConstants.PermissionCreateStickyTopics
};
var lockTopics = new Permission {
Name = AppConstants.PermissionLockTopics
};
var voteInPolls = new Permission {
Name = AppConstants.PermissionVoteInPolls
};
var createPolls = new Permission {
Name = AppConstants.PermissionCreatePolls
};
var createTopics = new Permission {
Name = AppConstants.PermissionCreateTopics
};
var attachFiles = new Permission {
Name = AppConstants.PermissionAttachFiles
};
var denyAccess = new Permission {
Name = AppConstants.PermissionDenyAccess
};
_permissionService.Add(readOnly);
_permissionService.Add(deletePosts);
_permissionService.Add(editPosts);
_permissionService.Add(stickyTopics);
_permissionService.Add(lockTopics);
_permissionService.Add(voteInPolls);
_permissionService.Add(createPolls);
_permissionService.Add(createTopics);
_permissionService.Add(attachFiles);
_permissionService.Add(denyAccess);
// Set up global permissions
var editMembers = new Permission {
Name = AppConstants.PermissionEditMembers, IsGlobal = true
};
_permissionService.Add(editMembers);
// create the admin user and put him in the admin role
var admin = new MembershipUser
{
Email = "*****@*****.**",
UserName = "******",
Password = "******",
IsApproved = true,
DisableEmailNotifications = false,
DisablePosting = false,
DisablePrivateMessages = false
};
_membershipService.CreateUser(admin);
// Do a save changes just in case
unitOfWork.SaveChanges();
// Put the admin in the admin role
var adminRole = _roleService.GetRole(AppConstants.AdminRoleName);
admin.Roles = new List <MembershipRole> {
adminRole
};
unitOfWork.Commit();
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
installerResult.Exception = ex.InnerException;
installerResult.Message = "Error creating the initial data >> Admin user & Permissions";
installerResult.Successful = false;
return(installerResult);
}
}
return(installerResult);
}
public void Execute(IJobExecutionContext context)
{
using (var unitOfWork = _unitOfWorkManager.NewUnitOfWork())
{
try
{
var settings = _settingsService.GetSettings(false);
var timeFrame = settings.MarkAsSolutionReminderTimeFrame ?? 0;
if (timeFrame > 0 && settings.EnableMarkAsSolution)
{
var remindersToSend = _topicService.GetMarkAsSolutionReminderList(timeFrame);
if (remindersToSend.Any())
{
var amount = remindersToSend.Count;
// Use settings days amount and also mark topics as reminded
// Only send if markassolution is enabled and day is not 0
foreach (var markAsSolutionReminder in remindersToSend)
{
// Topic Link
var topicLink = $"<a href=\"{settings.ForumUrl.TrimEnd('/')}{markAsSolutionReminder.Topic.NiceUrl}\">{markAsSolutionReminder.Topic.Name}</a>";
// Create the email
var sb = new StringBuilder();
sb.AppendFormat("<p>{0}</p>", string.Format(_localizationService.GetResourceString("Tasks.MarkAsSolutionReminderJob.EmailBody"),
topicLink,
settings.ForumName, markAsSolutionReminder.PostCount));
// create the emails and only send them to people who have not had notifications disabled
var user = markAsSolutionReminder.Topic.User;
var email = new Email
{
Body = _emailService.EmailTemplate(user.UserName, sb.ToString(), settings),
EmailTo = user.Email,
NameTo = user.UserName,
Subject = string.Format(
_localizationService.GetResourceString("Tasks.MarkAsSolutionReminderJob.Subject"),
settings.ForumName)
};
// and now pass the emails in to be sent
// We have to pass the current settings to SendMail when it's within a task
_emailService.SendMail(email, settings);
// And now mark the topic as reminder sent
markAsSolutionReminder.Topic.SolvedReminderSent = true;
}
unitOfWork.Commit();
_loggingService.Error($"{amount} Mark as solution reminder emails sent");
}
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
_loggingService.Error(ex);
}
}
}