public TimeSheetDTO GetTimeSheet()
{
using (var uow = _unitOfWorkFactory.Create <TimeSheetContext>())
{
var ts = GetTimeSheet(uow);
var entries = this.GetEntries(uow, ts.Period);
ts.LoadEntries(entries);
uow.SaveChanges();
return(new TimeSheetDTO(ts));
}
}
/// <summary>
/// Регистрация пользователя
/// </summary>
private void Scenario1()
{
using (unitOfWorkFactory.Create())
{
var account = new Account("email", "password");
account.AddRole(Role.Admin);
accountRepository.Save(account);
}
}
public void OnNavigatedTo(NavigationContext navigationContext)
{
using (var uow = _unitOfWorkFactory.Create <SettingsContext>())
{
var s = uow.Repository <Settings>().GetAll().FirstOrDefault();
if (s != null)
{
this.Id = s.Id;
this.SettingName = s.Name;
this.SettingValue = s.Value;
}
}
}
public void Create_WithoutTransaction()
{
// Arrange
_connection.Setup(p => p.Open());
_connectionFactory.Setup(p => p.Create()).Returns(_connection.Object);
// Act
var result = _target.Create();
// Assert
Assert.IsNotNull(result);
_connection.Verify(p => p.Open(), Times.Once);
_connectionFactory.Verify(p => p.Create(), Times.Once);
}
public void EmailNotifySubscriber(ReleaseForm release)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var qList = uow.Repository <UserList>().Where(w => w.IsDeleted == false && w.IsEmailNotifyOfNewRelease);
var qConnector = uow.Repository <Connector>().Where(w => w.IsDeleted == false && w.ConnectorType == R.ConnectorType.SERIES_USERLIST && w.SourceID == release.SeriesID);
var qUser = uow.Repository <User>().Where(w => w.Email.Contains("@"));
var lists = qList.Join(qConnector, l => l.ID, c => c.TargetID, (l, c) => l);
var users = qUser.Join(lists, u => u.ID, l => l.UserID, (u, l) => u).ToList();
if (!users.Any())
{
return;
}
var email = new MailMessage()
{
Subject = string.Format("New Release - {0}", release.Title),
Body = string.Format("http://www.fanslations.com/release/detail/{0}/{1}", release.Title.ToSeo(), release.ID)
};
// add subscriber to bcc
foreach (var user in users)
{
email.Bcc.Add(user.Email);
}
email.To.Add("*****@*****.**");
EmailService.Instance.Send(email);
}
}
public GroupDetail GetGroup(GroupCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new GroupService(uow);
var detail = service.Get(criteria);
detail.Series = service.View <Connector>()
.Where(w => w.IsDeleted == false && w.ConnectorType == R.ConnectorType.SERIES_GROUP && w.TargetID == detail.ID)
.Join(service.View <Series>().All(), c => c.SourceID, s => s.ID, (c, s) => s).ToList();
detail.Releases = service.View <Release>().Where(w => w.GroupID == detail.ID).ToList();
detail.Feeds = service.View <Connector>()
.Where(w => w.ConnectorType == R.ConnectorType.GROUP_FEED && w.SourceID == detail.ID)
.Join(service.View <Feed>().All(), c => c.TargetID, f => f.ID, (c, f) => f).ToList();
detail.Glossaries = service.View <Glossary>().Where(w => w.SourceTable == R.SourceTable.GROUP && w.SourceID == detail.ID).ToList();
detail.Summarize = service.View <Summarize>().Where(w => w.SourceTable == R.SourceTable.GROUP && w.SourceID == detail.ID).SingleOrDefault() ?? new Summarize();
detail.UserAction = new UserActionFacade().Get(new ViewForm {
UserID = criteria.ByUserID, SourceID = detail.ID, SourceTable = R.SourceTable.GROUP
});
return(detail);
}
}
private void dataGridView1_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
{
if (e.RowIndex > -1)//datagridview'ın herhangi birsatırın indisi olup olmadığını kontrol ediyoruz.
{
Satir = dataGridView1.Rows[e.RowIndex]; //tıklanan satırıstatic olan bir satir tutucusuna atıyoruz.
EmanetGeriTeslim emanetGeriTeslim = new EmanetGeriTeslim(); //detay formunu oluşturuyoruz.
emanetGeriTeslim.ShowDialog(); //show metodunu çağırıyoruz.bu sayede formu görünür yapıyoruz.
}
using (var uow = (AdoNetUnitOfWork)UnitOfWorkFactory.Create(UnitOfWorkFactory.connectiontype.SQL))
{
try
{
var repos1 = new EmanetlerRepository(uow);
List <Emanet> emanetler = repos1.GetAll();
uow.SaveChanges();
dataGridView1.DataSource = emanetler;
}
catch (Exception ex)
{
throw new Exception("Put your error message here.", ex);
}
}
}
public ActionResult Login(LoginModel login, string retUrl)
{
if (!ModelState.IsValid)
{
return(View(login));
}
bool achou = false;
string usuario = login.Usuario;
string senha = login.Senha;
bool lembrar = login.LembrarMe;
using (var uow = UnitOfWorkFactory.Create())
{
var loginRepositorio = new LoginRepositorio(uow);
achou = loginRepositorio.Login(usuario, senha);
}
if (achou)
{
FormsAuthentication.SetAuthCookie(usuario, lembrar);
if (Url.IsLocalUrl(retUrl))
{
return(Redirect(retUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "Login Inválido!!");
}
return(View(login));
}
private void timer1_Tick(object sender, EventArgs e)
{
using (var uow = (AdoNetUnitOfWork)UnitOfWorkFactory.Create(UnitOfWorkFactory.ConnectionType.SQL, Connection.connectionString))
{
try
{
var dRepos = new DoctorRepository(uow);
dRepos.CheckLeave();
uow.SaveChanges();
}
catch
{
}
}
using (var uow = (AdoNetUnitOfWork)UnitOfWorkFactory.Create(UnitOfWorkFactory.ConnectionType.SQL, Connection.connectionString))
{
try
{
var nRepos = new NurseRepository(uow);
nRepos.CheckLeave();
uow.SaveChanges();
}
catch
{
}
}
timer1.Enabled = false;
}
public IList <UserList> GetListHasReleases(ListCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var qList = uow.Repository <UserList>().Where(w => w.IsDeleted == false && w.UserID == criteria.ByUserID && w.IsNotifyOfNewRelease);
var qConnector = uow.Repository <Connector>().Where(w => w.IsDeleted == false && w.ConnectorType == R.ConnectorType.SERIES_USERLIST);
var qRelease = uow.Repository <Release>().Where(w => w.IsDeleted == false && w.SeriesID > 0);
var qRead = uow.Repository <UserRead>().Where(w => w.UserID == criteria.ByUserID && w.SourceTable == R.SourceTable.RELEASE);
var seriesList = qList.Join(qConnector, l => l.ID, c => c.TargetID, (l, c) => new { l.ID, l.Name, SeriesID = c.SourceID });
var allReleases = qRelease.Join(seriesList, r => r.SeriesID, l => l.SeriesID,
(r, l) => new { r.ID, r.Date, UserListID = l.ID, l.Name, r.SeriesID });
var readReleases = qRead.Join(allReleases, r => r.SourceID, rl => rl.ID,
(r, rl) => rl).GroupBy(g => new { g.SeriesID }).Select(s => new { s.Key.SeriesID, Date = s.Max(m => m.Date) });
var untouchReleases = allReleases.Where(w => !readReleases.Any(w2 => w2.SeriesID == w.SeriesID))
.GroupBy(g => new { g.SeriesID })
.Select(s => new { s.Key.SeriesID, Date = DateTime.MinValue });
// only return releases that has been read once
var unreadReleases = readReleases.Union(untouchReleases).SelectMany(s => allReleases.Where(w => (w.SeriesID == s.SeriesID && w.Date > s.Date))).ToList();
return(unreadReleases.GroupBy(g => new { g.UserListID, g.Name }).Select(s => new UserList {
ID = s.Key.UserListID, Name = s.Key.Name, Type = s.Count(), UpdatedDate = s.Max(m => m.Date)
}).ToList());
}
}
public async Task <Result> TriggerActionAsync(object id, string action, string triggeredBy, CancellationToken cancellationToken)
{
var actionEvents = new ActionEvents();
using (var unitOfWork = UnitOfWorkFactory.Create())
{
var entity = await unitOfWork.ReadOnlyRepository <TContext, TEntity>().GetByIdAsync(cancellationToken, id);
if (entity is IEntityAggregateRoot)
{
IDomainActionEvent actionEvent = actionEvents.CreateEntityActionEvent(action, null, entity, triggeredBy);
if (actionEvent != null)
{
((IEntityAggregateRoot)entity).AddActionEvent(actionEvent);
var validationResult = unitOfWork.Repository <TContext, TEntity>().Update(entity, triggeredBy);
if (validationResult.IsFailure)
{
return(Result.ObjectValidationFail <TEntity>(validationResult.ObjectValidationErrors));
}
return(await unitOfWork.CompleteAsync(cancellationToken).ConfigureAwait(false));
}
}
}
return(Result.Ok());
}
public AuthSession GetAuthSession(UserCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new UserService(uow);
var detail = service.Get(criteria);
if (detail == null)
{
var form = new UserForm
{
Username = criteria.Username,
//Location = criteria.Username,
};
var id = service.SaveChanges(form);
return(GetAuthSession(criteria));
}
var session = new AuthSession();
session.UserID = detail.ID;
session.Username = detail.Username;
session.FirstName = detail.FirstName;
session.LastName = detail.LastName;
session.Email = detail.Email;
criteria.ByUserID = detail.ID;
session.HiddenSeriesIDs = GetHiddenSeriesIDs(criteria);
return(session);
}
}
public IList <int> GetHiddenSeriesIDs(BaseCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new UserService(uow);
// start - get series IDs that user don't want to see via preferences
var connectorTypes = new[] { R.ConnectorType.SERIES_TAGCATEGORY, R.ConnectorType.SERIES_TAGGENRE };
var preferenceTypes = new[] { R.PreferenceType.CATEGORY, R.PreferenceType.GENRE };
var qConnector = service.View <Connector>().Where(w => connectorTypes.Contains(w.ConnectorType));
var qUserPreference = service.View <UserPreference>().Where(w => w.UserID == criteria.ByUserID && preferenceTypes.Contains(w.Type) && w.SourceTable == R.SourceTable.TAG);
var hiddenSeriesIDs = qConnector.Join(qUserPreference, cn => cn.TargetID, up => up.SourceID,
(cn, up) => new { cn.SourceID, up.Score })
.GroupBy(g => new { g.SourceID, g.Score })
.Where(w => w.Sum(s => s.Score) < 0)
.Select(s => s.Key.SourceID);
// end
// start - get series IDs that user don't want to vee via user lists
var hiddenUserListIDs = service.View <UserList>().Where(w => w.IsDeleted == false && w.UserID == criteria.ByUserID && w.IsHiddenInFrontpage == true).Select(s => s.ID).ToList();
var qConnector2 = service.View <Connector>().Where(w => w.ConnectorType == R.ConnectorType.SERIES_USERLIST);
var hiddenSeriesIDs2 = qConnector2.Where(w => w.ConnectorType == R.ConnectorType.SERIES_USERLIST && hiddenUserListIDs.Contains(w.TargetID)).Select(s => s.SourceID);
// end
return(hiddenSeriesIDs.Union(hiddenSeriesIDs2).ToList());
}
}
public void NewSessionAndUpdatePhase()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var sessionOfExperts = new SessionOfExperts("BaseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(sessionOfExperts);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var session = LinqProvider.Query <SessionOfExperts>().Single();
session.NextPhaseOrFinish();
GetRepository <SessionOfExperts>().AddOrUpdate(session);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var session = LinqProvider.Query <SessionOfExperts>().Single();
session.CurrentPhase.Should().Be(SessionPhase.SpecifyingAssociationsTypes);
session.StartTime.Should().BeNow();
session.BaseNotion.Should().Be("BaseNotion");
}
}
public RemoveFromFriendsResponse RemoveFromFriends(ISession session, RemoveFromFriendsRequest request)
{
var response = request.CreateResponse <RemoveFromFriendsResponse>();
response.Success = true;
if (session.User.Friends.All(i => i.Id != request.TargetUserId))
{
response.Success = false;
return(response);
}
using (var uow = UnitOfWorkFactory.Create())
{
uow.Attach(session.User);
var friend = uow.UsersRepository.FirstMatching(UserSpecification.Id(request.TargetUserId));
if (friend == null)
{
response.Success = false;
}
else
{
session.User.Friends.Remove(friend);
uow.Commit();
}
}
return(response);
}
public GetUserDetailsResponse GetUserDetails(ISession session, GetUserDetailsRequest request)
{
var response = request.CreateResponse <GetUserDetailsResponse>();
using (var uow = UnitOfWorkFactory.Create())
{
Specification <User> spec = null;
if (request.UserId != 0)
{
spec = UserSpecification.Id(request.UserId);
}
else if (!string.IsNullOrEmpty(request.Name))
{
spec = UserSpecification.Name(request.Name);
}
else
{
return(response); //invalid request
}
var user = uow.UsersRepository.FirstMatching(spec);
if (user != null)
{
response.User = user.ProjectedAs <UserDto>();
response.IsFriend = session.User.Friends.Any(p => p.Id == user.Id);
uow.Attach(session.User);
}
}
return(response);
}
public T Get(BaseCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
return(new T());
}
}
/// <summary>
/// Resets user's photo to default one
/// </summary>
public ResetPhotoResponse ResetPhoto(ISession session, ResetPhotoRequest request)
{
var response = request.CreateResponse <ResetPhotoResponse>();
try
{
using (var uow = UnitOfWorkFactory.Create())
{
var target = uow.UsersRepository.FirstMatching(UserSpecification.Id(request.TargetId));
if (target != null)
{
response.NewPhotoId = target.ResetPhoto(session.User);
uow.Commit();
response.Success = true;
}
}
}
catch (ModeratorsRightsRequiredException)
{
response.Success = false;
}
if (response.Success)
{
_profileChangesNotificator.NotifyEverybodyInChatAboutProfileChanges(request.TargetId, new Dictionary <string, object> {
{ "PhotoId", response.NewPhotoId }
});
}
return(response);
}
public ListDetail Get(ListCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new ListService(uow);
var detail = service.Get(criteria);
// connector
detail.Connectors = service.View <Connector>()
.Where(w => w.IsDeleted == false && w.ConnectorType == R.ConnectorType.SERIES_USERLIST)
.Where(w => w.TargetID == detail.ID).ToList();
// series
var listSeriesIDs = detail.Connectors.Select(s => s.SourceID).ToList();
detail.Series = new SeriesService(uow).Search(new SearchModel <SeriesCriteria>
{
Criteria = new SeriesCriteria {
IDs = listSeriesIDs
},
PagedListConfig = new PagedListConfig {
PageSize = int.MaxValue
}
}).Data;
// releases
detail.Releases = service.View <Release>().Where(w => listSeriesIDs.Contains(w.SeriesID)).ToList();
// user reads
var releaseIDs = detail.Releases.Select(s => s.ID);
detail.Reads = service.View <UserRead>().Where(w => w.UserID == criteria.ByUserID)
.Where(w => w.SourceTable == R.SourceTable.RELEASE)
.Where(w => releaseIDs.Contains(w.SourceID)).ToList();
return(detail);
}
}
public ReleaseDetail GetRelease(ReleaseCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new ReleaseService(uow);
var detail = service.Get(criteria);
detail.Series = service.View <Series>().Where(w => w.ID == detail.SeriesID).SingleOrDefault() ?? new Series();
detail.Group = service.View <Group>().Where(w => w.ID == detail.GroupID).SingleOrDefault() ?? new Group();
detail.Summarize = service.View <Summarize>().Where(w => w.SourceTable == R.SourceTable.RELEASE && w.SourceID == detail.ID).SingleOrDefault() ?? new Summarize();
// get data for user lists
detail.Connectors = service.View <Connector>().Where(w => w.IsDeleted == false && w.SourceID == detail.SeriesID).ToList();
detail.UserLists = service.View <UserList>().Where(w => w.IsDeleted == false && w.UserID == criteria.ByUserID)
.OrderBy(o => o.Priority == 0 ? int.MaxValue : o.Priority).ThenBy(o => o.Name).ToList();
detail.UserAction = new UserActionFacade().Get(new ViewForm {
UserID = criteria.ByUserID, SourceID = detail.ID, SourceTable = R.SourceTable.RELEASE
});
detail.Sticky = service.View <Sticky>().Where(w => w.SourceID == detail.ID && w.SourceTable == R.SourceTable.RELEASE).SingleOrDefault() ?? new Sticky();
return(detail);
}
}
public IList <UserList> GetListTemplates()
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
return(uow.Repository <UserList>().Where(w => w.IsDeleted == false && w.UserID == 0).ToList());
}
}
public override void Execute(UpdateVaultConfigurationContext context)
{
var configuration = context.Configuration;
using (var uow = UnitOfWorkFactory.Create())
{
var vault = uow.VaultRepository.GetById(configuration.Id);
vault.Name = configuration.Name;
vault.Description = configuration.Description;
vault.OpenTime = configuration.OpenTime;
vault.CloseTime = configuration.CloseTime;
vault.Users.Clear();
foreach (var userId in configuration.SelectedUsers)
{
var user = uow.UserRepository.GetById(userId);
vault.Users.Add(user);
}
uow.VaultRepository.Update(vault);
uow.Commit();
}
}
public Result TriggerAction(object id, string action, string triggeredBy)
{
var actionEvents = new ActionEvents();
using (var unitOfWork = UnitOfWorkFactory.Create())
{
var entity = unitOfWork.ReadOnlyRepository <TContext, TEntity>().GetById(id);
if (entity is IEntityAggregateRoot)
{
IDomainActionEvent actionEvent = actionEvents.CreateEntityActionEvent(action, null, entity, triggeredBy);
if (actionEvent != null)
{
((IEntityAggregateRoot)entity).AddActionEvent(actionEvent);
var validationResult = unitOfWork.Repository <TContext, TEntity>().Update(entity, triggeredBy);
if (validationResult.IsFailure)
{
return(Result.ObjectValidationFail <TEntity>(validationResult.ObjectValidationErrors));
}
return(unitOfWork.Complete());
}
}
}
return(Result.Ok());
}
/// <inheritdoc />
public void Execute(IDatabaseConfig config, IModelSetup setup, string setupData)
{
var unitOfWorkFactory = new UnitOfWorkFactory <TContext>(_dbContextManager);
using (var uow = unitOfWorkFactory.Create(config))
setup.Execute(uow, setupData);
}
public IEnumerable <Permiso> Todos()
{
using (IUnitOfWork unitOfWork = UnitOfWorkFactory.Create())
{
return(new PermisoDAL(unitOfWork).Todos());
}
}
private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex == 4)
{
bool _excep = false;
int data = 0;
using (var uow = (AdoNetUnitOfWork)UnitOfWorkFactory.Create(UnitOfWorkFactory.ConnectionType.SQL, Connection.connectionString))
{
try
{
var aRepos = new Repositories.AppoinmentRepository(uow);
data = aRepos.UpdateSituation(dataGridView1.Rows[e.RowIndex]);
uow.SaveChanges();
dataGridView1.Columns.RemoveAt(4);
FiilToGridView();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
_excep = true;
}
}
if (_excep == false && data == 1)
{
MessageBox.Show("Operation is successfull");
}
}
}
private void PrepareRepository()
{
var unitOfWorkFactory = new UnitOfWorkFactory();
_unitOfWork = unitOfWorkFactory.Create();
_repository = new UsersRepository(_unitOfWork);
}
public async Task <ICollection <ItemPackageDTO> > GetAllPackagesAsync()
{
using (UnitOfWorkFactory.Create())
{
return(await new ItemPackagesQuery(UnitOfWorkFactory).ExecuteAsync());
}
}
protected override async Task LoadElements()
{
//zeby message z gniazdem mogl dojsc
await Task.Delay(200);
using (var uow = UnitOfWorkFactory.Create())
{
if (gniazdoProdukcyjne == null)
{
ListOfVMEntities = new ObservableCollection <tblProdukcjaZlecenieTowar>
(
await uow.tblProdukcjaZlecenieTowar.WhereAsync(t => t.IDProdukcjaZlecenie != null &&
t.IDProdukcjaZlecenie != 0)
);
}
else
{
ListOfVMEntities = new ObservableCollection <tblProdukcjaZlecenieTowar>
(
await uow.tblProdukcjaZlecenieTowar.WhereAsync(t => t.IDProdukcjaZlecenie != null &&
t.IDProdukcjaZlecenie != 0 &&
t.IDProdukcjaGniazdoProdukcyjne == gniazdoProdukcyjne.IDProdukcjaGniazdoProdukcyjne &&
(t.tblProdukcjaZlecenie.IDProdukcjaZlecenieStatus == (int)ProdukcjaZlecenieStatusEnum.Oczekuje ||
t.tblProdukcjaZlecenie.IDProdukcjaZlecenieStatus == (int)ProdukcjaZlecenieStatusEnum.WTrakcie)
)
);
}
}
ListOfVMEntities = new ObservableCollection <tblProdukcjaZlecenieTowar>
(ListOfVMEntities.OrderByDescending(d => d.tblProdukcjaZlecenie.NrZlecenia));
}
public void NodeRepository_GetSemanticNetworkBySession()
{
using (UnitOfWorkFactory.Create()) {
var expertRepository = new NodeRepository(GetRepository <Node>(), LinqProvider);
var actualSemanticNetwork = expertRepository.GetSemanticNetworkBySession(_session1);
actualSemanticNetwork.Concepts.Should().BeEquivalentTo(
new ConceptReadModel(
"notion1",
"type",
new List <VergeReadModel> {
new VergeReadModel("notion2", "type", "notion1", "type", "type", 20)
},
new List <VergeReadModel>
{
new VergeReadModel("notion1", "type", "notion2", "type", "type", 20)
}),
new ConceptReadModel(
"notion2",
"type",
new List <VergeReadModel> {
new VergeReadModel("notion1", "type", "notion2", "type", "type", 20)
},
new List <VergeReadModel>
{
new VergeReadModel("notion2", "type", "notion1", "type", "type", 20)
}));
}
}
