//readonly Tree masterTree;
//readonly Tree currentTree;
public Stalker(String localRepo, String sourceFileName, String ignoreFileName, String localStalkBranch = null, String targetTag = null, String localMaster = "master")
{
repo = new Repository (localRepo);
master = repo.Branches.Single (branch => branch.FriendlyName == localMaster);
if (targetTag != null) {
tag = repo.Tags.Single (t => t.FriendlyName == targetTag);
}
// if (localStalkBranch != null)
head = repo.Branches.Single (branch => branch.FriendlyName == localStalkBranch);
// else
// head = repo.Head;
// if (head != repo.Branches.Single (b => b.IsCurrentRepositoryHead)) {
// repo.Checkout(head);
// }
// head = repo.Branches.Single(b => b.IsCurrentRepositoryHead);
//var filter = new CommitFilter { Since = repo.Branches["master"], Until = repo.Branches["development"] };
//masterTree = repo.Lookup<Tree>(master.Tip.Sha);
//currentTree = repo.Lookup<Tree>(head.Tip.Sha);
try {
sources = File.ReadAllLines (Path.Combine (localRepo, sourceFileName));
} catch {
} finally {
}
try {
ignore = File.ReadAllLines (Path.Combine (localRepo, ignoreFileName));
} catch {
} finally {
}
}
public User Login(string username, string password)
{
var session = NHibernateSessionManager.GetLocalSession();
var macAddress = _clientAdapter.GetCurrentClientMacAddress();
var user = _userRepository.LoginActiveUser(username, password);
var terminal = _terminalRepository.FindByMac(macAddress);
if (user.IsNull())
{
throw new ApplicationException(@"User not found");
}
if (terminal == null)
{
session.DoTransactional(sess =>
terminal = _terminalRepository.Insert(
new Terminal(
string.Format(@"T-{0}/{1:00}", user.Employee.Branch.Code ,_terminalRepository.Count() + 1),
macAddress,
user.Employee.Branch
)
)
);
}
LoggedInUser = user;
LoggedInUserBranch = user.Employee.Branch;
LoggedInTerminal = terminal;
return user;
}
/// <summary>
/// Checkout the tip commit of the specified <see cref="Branch"/> object. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
/// as a detached HEAD.
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="branch">The <see cref="Branch"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, Branch branch, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(branch, "branch");
Ensure.ArgumentNotNull(options, "options");
// Make sure this is not an unborn branch.
if (branch.Tip == null)
{
throw new UnbornBranchException("The tip of branch '{0}' is null. There's nothing to checkout.",
branch.FriendlyName);
}
if (!branch.IsRemote && !(branch is DetachedHead) &&
string.Equals(repository.Refs[branch.CanonicalName].TargetIdentifier, branch.Tip.Id.Sha,
StringComparison.OrdinalIgnoreCase))
{
Checkout(repository, branch.Tip.Tree, options, branch.CanonicalName);
}
else
{
Checkout(repository, branch.Tip.Tree, options, branch.Tip.Id.Sha);
}
return repository.Head;
}
/// <summary>Create <see cref="RenameBranchDialog"/>.</summary>
/// <param name="branch">Branch to rename.</param>
/// <exception cref="ArgumentNullException"><paramref name="branch"/> == <c>null</c>.</exception>
public RenameBranchDialog(Branch branch)
{
Verify.Argument.IsNotNull(branch, "branch");
Verify.Argument.IsFalse(branch.IsDeleted, "branch",
Resources.ExcObjectIsDeleted.UseAsFormat("Branch"));
_branch = branch;
InitializeComponent();
Localize();
var inputs = new IUserInputSource[]
{
_newNameInput = new TextBoxInputSource(_txtNewName),
};
_errorNotifier = new UserInputErrorNotifier(NotificationService, inputs);
SetupReferenceNameInputBox(_txtNewName, ReferenceType.LocalBranch);
var branchName = branch.Name;
_txtOldName.Text = branchName;
_txtNewName.Text = branchName;
_txtNewName.SelectAll();
GitterApplication.FontManager.InputFont.Apply(_txtNewName, _txtOldName);
_controller = new RenameBranchController(branch) { View = this };
}
public ElectronicObject(string catalogueNumber, string manufacturer, string model, string description, int quantity, Branch category, decimal price, Color color, double display, int capacity)
: base(catalogueNumber, manufacturer, model, description, quantity, category, price)
{
this.display = display;
this.capacity = capacity;
this.color = color;
}
/// <summary>
/// Gets the <see cref="BranchConfig"/> for the current commit.
/// </summary>
public static BranchConfig GetBranchConfiguration(GitVersionContext context, Branch targetBranch, IList<Branch> excludedInheritBranches = null)
{
var matchingBranches = LookupBranchConfiguration(context.FullConfiguration, targetBranch).ToArray();
BranchConfig branchConfiguration;
if (matchingBranches.Length > 0)
{
branchConfiguration = matchingBranches[0];
if (matchingBranches.Length > 1)
{
Logger.WriteWarning(string.Format(
"Multiple branch configurations match the current branch branchName of '{0}'. Using the first matching configuration, '{1}'. Matching configurations include: '{2}'",
targetBranch.FriendlyName,
branchConfiguration.Name,
string.Join("', '", matchingBranches.Select(b => b.Name))));
}
}
else
{
Logger.WriteInfo(string.Format(
"No branch configuration found for branch {0}, falling back to default configuration",
targetBranch.FriendlyName));
branchConfiguration = new BranchConfig { Name = string.Empty };
ConfigurationProvider.ApplyBranchDefaults(context.FullConfiguration, branchConfiguration, "");
}
return branchConfiguration.Increment == IncrementStrategy.Inherit ?
InheritBranchConfiguration(context, targetBranch, branchConfiguration, excludedInheritBranches) :
branchConfiguration;
}
public FinancialStatusByBranchController(Branch branch)
: base(UITableViewStyle.Grouped, null)
{
Autorotate = false;
this.branch = branch;
buildReport ();
}
public BranchWrapper(Repository repo, Branch branch)
{
this.repo = repo;
this.branch = branch;
IsRemote = branch.IsRemote;
if (branch.TrackedBranch != null)
{
TrackedBranch = new BranchWrapper(repo, branch.TrackedBranch);
}
IsTracking = branch.IsTracking;
TrackingDetails = (Func<object, Task<object>>)(async (j) => { return branch.TrackingDetails; });
IsCurrentRepositoryHead = (Func<object, Task<object>>)(async (j) => { return branch.IsCurrentRepositoryHead; });
Tip = async (j) => { return new CommitWrapper(branch.Tip); };
UpstreamBranchCanonicalName = (Func<object, Task<object>>)(async (j) => { return branch.UpstreamBranchCanonicalName; });
Remote = branch.Remote;
CanonicalName = branch.CanonicalName;
Commits = (Func<object, Task<object>>)(async (j) => {
if (j != null)
{
Commit after = repo.Lookup<Commit>((string)j);
Commit until = branch.Tip;
Commit ancestor = repo.Commits.FindMergeBase(after, until) ?? after;
return CommitsAfter(after, until, ancestor).Distinct().Select(c => new CommitWrapper(c));
}
else
{
return branch.Commits.Select(c => new CommitWrapper(c));
}
});
Name = branch.Name;
}
public static KeyValuePair<string, BranchConfig> GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)
{
var matchingBranches = LookupBranchConfiguration(config, currentBranch);
if (matchingBranches.Length == 0)
{
var branchConfig = new BranchConfig();
ConfigurationProvider.ApplyBranchDefaults(config, branchConfig);
return new KeyValuePair<string, BranchConfig>(string.Empty, branchConfig);
}
if (matchingBranches.Length == 1)
{
var keyValuePair = matchingBranches[0];
var branchConfiguration = keyValuePair.Value;
if (branchConfiguration.Increment == IncrementStrategy.Inherit)
{
return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, keyValuePair, branchConfiguration, config, excludedInheritBranches);
}
return keyValuePair;
}
const string format = "Multiple branch configurations match the current branch branchName of '{0}'. Matching configurations: '{1}'";
throw new Exception(string.Format(format, currentBranch.Name, string.Join(", ", matchingBranches.Select(b => b.Key))));
}
/// <summary>
/// Create New Branch
/// </summary>
/// <param name="NewBranch"></param>
public void CreateBranch(Branch NewBranch)
{
string qryInsertBranch =
@"INSERT INTO [dbo].[Company]
([BranchID]
, [CompanyID]
, [BranchRegion]
, [BranchCode]
, [BranchName]
, [BranchHotelName]
, [BranchSpaName]
, [BranchAddress]
, [BranchCity]
, [BranchState]
, [BranchCountry]
, [BranchContactNo]
, [BranchComment]
, [BranchCreatedBy])
values
(@BranchID, @CompanyID, @BranchRegion, @BranchCode, @BranchName,
@BranchHotelName, @BranchSpaName, @BranchAddress, @BranchCity,
@BranchState, @BranchCountry, @BranchContactNo, @BranchComment, @BranchCreatedBy)";
//creates new Branch
this._con.Query<int>(qryInsertBranch, NewBranch);
}
public Employee(Branch branch, Position position, PersonName name, Gender gender)
: base(name)
{
_branch = branch;
_position = position;
base.Gender = gender;
}
/// <summary>
/// Push the specified branch to its tracked branch on the remote.
/// </summary>
/// <param name="network">The <see cref="Network"/> being worked with.</param>
/// <param name="branch">The branch to push.</param>
/// <param name="pushOptions"><see cref="PushOptions"/> controlling push behavior</param>
/// <exception cref="LibGit2SharpException">Throws if either the Remote or the UpstreamBranchCanonicalName is not set.</exception>
public static void Push(
this Network network,
Branch branch,
PushOptions pushOptions = null)
{
network.Push(new[] { branch }, pushOptions);
}
public int NumberOfCommitsOnBranchSinceCommit(Branch branch, Commit commit)
{
var olderThan = branch.Tip.Committer.When;
return branch.Commits
.TakeWhile(x => x != commit)
.Count();
}
public static Commit LatestMergeCommit(this Branch thisBranch, Branch otherBranch)
{
IEnumerable<Commit> otherBranchCommits = otherBranch.Commits;
if (otherBranchCommits.Contains(thisBranch.Tip))
{
// Current branch is merged back to otherBranch.
// So we find the last commit on otherBranch before this merge and all it's ancestors.
var otherTipAfterMerge =
otherBranchCommits.SkipWhile(c => c.Parents.All(p => p != thisBranch.Tip)).FirstOrDefault();
if (otherTipAfterMerge != null)
{
var thisTipBeforeMerge = otherTipAfterMerge.Parents.First(p => p != thisBranch.Tip);
otherBranchCommits =
new List<Commit> { thisTipBeforeMerge }.Concat(thisTipBeforeMerge.GetAllAncestors());
}
}
var branchCommits = thisBranch.Commits.Except(otherBranchCommits).ToList();
var branchCommitsMergedFromOtherBranch =
branchCommits.Where(c => c.IsMergeFrom(otherBranchCommits)).ToList();
if (branchCommitsMergedFromOtherBranch.Any())
{
return branchCommitsMergedFromOtherBranch.First().GetSingleParentFrom(otherBranchCommits);
}
if (branchCommits.Any())
{
return branchCommits.Last().GetSingleParentFrom(otherBranchCommits);
}
return null;
}
static string GetUnknownBranchSuffix(Branch branch)
{
var unknownBranchSuffix = branch.Name.Split('-', '/');
if (unknownBranchSuffix.Length == 1)
return branch.Name;
return unknownBranchSuffix[1];
}
static Branch[] CalculateWhenMultipleParents(IRepository repository, Commit currentCommit, ref Branch currentBranch, Branch[] excludedBranches)
{
var parents = currentCommit.Parents.ToArray();
var branches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[1]).ToList();
if (branches.Count == 1)
{
var branch = branches[0];
excludedBranches = new[]
{
currentBranch,
branch
};
currentBranch = branch;
}
else if (branches.Count > 1)
{
currentBranch = branches.FirstOrDefault(b => b.Name == "master") ?? branches.First();
}
else
{
var possibleTargetBranches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[0]).ToList();
if (possibleTargetBranches.Count > 1)
{
currentBranch = possibleTargetBranches.FirstOrDefault(b => b.Name == "master") ?? possibleTargetBranches.First();
}
else
{
currentBranch = possibleTargetBranches.FirstOrDefault() ?? currentBranch;
}
}
Logger.WriteInfo("HEAD is merge commit, this is likely a pull request using " + currentBranch.Name + " as base");
return excludedBranches;
}
void EnsureVersionIsValid(SemanticVersion version, Branch branch, BranchType branchType)
{
var msg = string.Format("Branch '{0}' doesn't respect the {1} branch naming convention. ",
branch.Name, branchType);
if (version.PreReleaseTag.HasTag())
{
throw new ErrorException(msg + string.Format("Supported format is '{0}-Major.Minor.Patch'.", branchType.ToString().ToLowerInvariant()));
}
switch (branchType)
{
case BranchType.Hotfix:
if (version.Patch == 0)
{
throw new ErrorException(msg + "A patch segment different than zero is required.");
}
break;
case BranchType.Release:
if (version.Patch != 0)
{
throw new ErrorException(msg + "A patch segment equals to zero is required.");
}
break;
case BranchType.Unknown:
break;
default:
throw new NotSupportedException(string.Format("Unexpected branch type {0}.", branchType));
}
}
public void Connect(Uri path)
{
// Try to see if ther is already a git repository inside the filesystem path
if (Repository.IsValid(m_fileSystemPath))
{
m_repository = new Repository(m_fileSystemPath, new RepositoryOptions());
}
else
{
var tempFolder = Guid.NewGuid().ToString("N");
m_bareWorkDirPath = System.IO.Path.Combine(m_fileSystemPath, tempFolder);
var ret = Repository.Clone(path.AbsoluteUri, m_bareWorkDirPath, new CloneOptions()
{
CredentialsProvider = (url, fromUrl, types) => new UsernamePasswordCredentials()
{
Password = m_password,
Username = m_userName,
},
Checkout = false,
IsBare = true,
});
m_repository = new Repository(m_bareWorkDirPath, new RepositoryOptions());
}
m_branch = m_repository.Branches[m_branchPath];
if (m_branch == null)
{
throw new Exception("Branch not found: " + m_branchPath);
}
}
public MainViewModel(KeyHooker hookerKey, MouseHooker hookerMouse, KeySenderInput keySenderInput, MouseSenderInput mouseSenderInput)
{
mHookerKey = hookerKey;
mHookerKey.SetHook();
mHookerMouse = hookerMouse;
mHookerMouse.SetHook();
mKeySenderInput = keySenderInput;
mMouseSenderInput = mouseSenderInput;
mStopMacroBranch = new Branch<IInput>(mInputEqualityComparer);
mMacrosModeBranch = new Branch<IInput>(mInputEqualityComparer);
Settings.Default.Setting = Settings.Default.Setting ?? new AppSettings(mInputEqualityComparer);
AppSettings settings = Settings.Default.Setting;
mTreeRoot = settings.TreeRoot;
mTreeSequence = settings.TreeSequence;
MacrosCollection = settings.MacrosCollection;
StopMacroCollection = settings.SequenceStopMacro;
MacrosModeCollection = settings.SequenceMacrosMode;
SequenceCollection = settings.Sequence;
MacroCollection = settings.Macro;
mSequenceReader = new HookNotRepeatReader(mHookerKey, SequenceCollection);
ObservableCollection<IInput> tempCollection = new ObservableCollection<IInput>(MacroCollection.Cast<IInput>());
tempCollection.CollectionChanged += ReadMacro_CollectionChanged;
mMacroReader = new MultiHookNotRepeatReader(new List<IHooker> { mHookerKey, mHookerMouse }, tempCollection);
mStopMacroReader = new HookNotRepeatReader(mHookerKey, StopMacroCollection);
mMacrosModeReader = new HookNotRepeatReader(mHookerKey, MacrosModeCollection);
RecordSequenceCommand = new RelayCommand(RecordSequence);
RecordMacroCommand = new RelayCommand(RecordMacro);
CreateMacrosCommand = new RelayCommand(CreateMacros);
CleanRowsSequenceCommand = new RelayCommand(CleanSequence);
CleanRowsMacroCommand = new RelayCommand(CleanMacro);
CleanRowsMacrosCommand = new RelayCommand(CleanMacros);
DeleteRowSequenceCommand = new RelayCommand<IInput>(RemoveSequence);
DeleteRowMacroCommand = new RelayCommand<InputDelay>(RemoveMacro);
DeleteRowMacrosCommand = new RelayCommand<Macros>(RemoveMacros);
StopRecordStopMacroCommand = new RelayCommand(StopRecordStopMacro);
StartRecordStopMacroCommand = new RelayCommand(StartRecordStopMacro);
StartRecordMacrosModeCommand = new RelayCommand(StartRecordMacrosMode);
StopRecordMacrosModeCommand = new RelayCommand(StopRecordMacrosMode);
SetDefaultDelayCommand = new RelayCommand(SetDefaultDelay);
StopAllRecordCommand = new RelayCommand(StopAllRecord);
mCancellationState = new CancelState<IInput>(mInputEqualityComparer);
StateWalker<IInput> machineWalker = new StateWalker<IInput>(mTreeRoot);
mHookerKey.Hooked += arg =>
{
State<IInput> currentState = machineWalker.WalkStates(arg);
return currentState is FunctionState<IInput>
? (bool)((FunctionState<IInput>)currentState).ExecuteFunction()
: currentState is CancellationFunctionState<IInput>
? (bool)((CancellationFunctionState<IInput>)currentState).ExecuteFunction(mCancellationState.CancelToken)
: true;
};
}
public AddDataForTestingTransaction()
{
ConnectionManager connectionManager = ConnectionManager.GetInstance(DataUtil.TESTDB);
_connection = connectionManager.SqlConnection;
_domainOfApplicationManagement = new EconomicActivityManager(DataUtil.TESTDB);
_clientManagement = new ClientManager(DataUtil.TESTDB);
_branch = new Branch {Id = 1, Name = "Default"};
}
public void addPcReply(Branch branch)
{
if (m_pcReplies == null)
{
m_pcReplies = new List<Branch>();
}
m_pcReplies.Add(branch);
}
public BranchPropertiesDialog(Branch branch)
{
Verify.Argument.IsNotNull(branch, "branch");
_branch = branch;
InitializeComponent();
}
public InternalNode(Branch branch, BranchCollection branches, bool isModified)
: base(branch)
{
Debug.Assert(branch.NodeType == NodeType.Internal);
Branches = branches;
IsModified = isModified;
}
public string GenerateCode(Branch b, string newLine)
{
if (string.IsNullOrEmpty(b.Path))
return string.Format("(\"{0}\", {1})", b.Name, GenerateCode(b.Tree, newLine)); ;
return string.Format("(\"{0}\", {1} {2} {3} )", b.Name,
b.Many ? "mapTrees" : "mapTree", b.Path, GenerateCode(b.Tree, newLine)); ;
}
public LeafNode(Branch branch, bool isModified)
: base(branch)
{
Debug.Assert(branch.NodeType == NodeType.Leaf);
Container = new Dictionary<Locator, IOrderedSet<IData, IData>>();
IsModified = isModified;
}
internal BranchTrackingDetails(Repository repo, Branch branch)
{
this.repo = repo;
this.branch = branch;
aheadBehind = new Lazy<Tuple<int?, int?>>(ResolveAheadBehind);
commonAncestor = new Lazy<Commit>(ResolveCommonAncestor);
}
static void EnsureVersionIsValid(SemanticVersion version, Branch branch)
{
if (version.Patch != 0)
{
var message = string.Format("Branch '{0}' doesn't respect the Release branch naming convention. A patch segment equals to zero is required.", branch.Name);
throw new WarningException(message);
}
}
public BranchDragDropMenu(Branch branch)
{
Verify.Argument.IsValidGitObject(branch, "branch");
_branch = branch;
Items.Add(new ToolStripMenuItem("TEST"));
}
internal BranchUpdater(Repository repo, Branch branch)
{
Ensure.ArgumentNotNull(repo, "repo");
Ensure.ArgumentNotNull(branch, "branch");
this.repo = repo;
this.branch = branch;
}
public static void Main()
{
IBL test = FactorySingletonBl.getInstanceBl();
List <group_local> zoo = new List <group_local>();
List <group_Order_dish> loo = new List <group_Order_dish>();
List <group_time> woo = new List <group_time>();
List <List <string_int> > poo = new List <List <string_int> >();
List <List <string_int> > goo = new List <List <string_int> >();
List <Branch> doo = new List <Branch>();
List <Branch> soo = new List <Branch>();
int hoo = new int();
double koo = new double();
Dish shnitzal = new Dish {
Get_Dish_id = 1, get_cal = 400, Get_name = "shnitzal", get_price = 70, get_size = Sizes.Medium, get_sup = Supervision.Glatt, get_typ = Types.Meat
};
Dish tost = new Dish {
Get_Dish_id = 2, get_cal = 350, Get_name = "tost", get_price = 25, get_size = Sizes.Medium, get_sup = Supervision.Glatt, get_typ = Types.Dairy
};
Dish salad = new Dish {
Get_Dish_id = 3, get_cal = 250, Get_name = "salad", get_price = 45, get_size = Sizes.Small, get_sup = Supervision.Basic, get_typ = Types.Vegeterian
};
Dish ravioly = new Dish {
Get_Dish_id = 4, get_cal = 380, Get_name = "ravioly", get_price = 56, get_size = Sizes.Medium, get_sup = Supervision.Mehadrin, get_typ = Types.Dairy
};
Dish shawarma = new Dish {
Get_Dish_id = 5, get_cal = 500, Get_name = "shawarma", get_price = 42, get_size = Sizes.Large, get_sup = Supervision.Mehadrin, get_typ = Types.Meat
};
Dish tiras = new Dish {
Get_Dish_id = 6, get_cal = 400, Get_name = "tiras", get_price = 70, get_size = Sizes.Medium, get_sup = Supervision.Glatt, get_typ = Types.Vegeterian
};
Dish melauach = new Dish {
Get_Dish_id = 7, get_cal = 350, Get_name = "melauach", get_price = 25, get_size = Sizes.Medium, get_sup = Supervision.Glatt, get_typ = Types.Dairy
};
Dish bread = new Dish {
Get_Dish_id = 8, get_cal = 250, Get_name = "bread", get_price = 45, get_size = Sizes.Small, get_sup = Supervision.Basic, get_typ = Types.Dairy
};
Dish chicken = new Dish {
Get_Dish_id = 9, get_cal = 380, Get_name = "chicken", get_price = 56, get_size = Sizes.Medium, get_sup = Supervision.Mehadrin, get_typ = Types.Meat
};
Dish chips = new Dish {
Get_Dish_id = 10, get_cal = 500, Get_name = "chips", get_price = 42, get_size = Sizes.Large, get_sup = Supervision.Mehadrin, get_typ = Types.Vegeterian
};
test.add_dish(shnitzal);
test.add_dish(tost);
test.add_dish(salad);
test.add_dish(ravioly);
test.add_dish(shawarma);
test.add_dish(tiras);
test.add_dish(melauach);
test.add_dish(bread);
test.add_dish(chicken);
test.add_dish(chips);
Ordered_Dish A = new Ordered_Dish {
get_dish_id = 1, Get_D_Order_code = 30, get_quantity = 7
};
Ordered_Dish B = new Ordered_Dish {
get_dish_id = 2, Get_D_Order_code = 31, get_quantity = 8
};
Ordered_Dish C = new Ordered_Dish {
get_dish_id = 3, Get_D_Order_code = 32, get_quantity = 9
};
Ordered_Dish D = new Ordered_Dish {
get_dish_id = 4, Get_D_Order_code = 33, get_quantity = 10
};
Ordered_Dish E = new Ordered_Dish {
get_dish_id = 5, Get_D_Order_code = 34, get_quantity = 11
};
Ordered_Dish F = new Ordered_Dish {
get_dish_id = 6, Get_D_Order_code = 35, get_quantity = 5
};
Ordered_Dish G = new Ordered_Dish {
get_dish_id = 7, Get_D_Order_code = 36, get_quantity = 1
};
Ordered_Dish H = new Ordered_Dish {
get_dish_id = 8, Get_D_Order_code = 37, get_quantity = 12
};
Ordered_Dish I = new Ordered_Dish {
get_dish_id = 9, Get_D_Order_code = 38, get_quantity = 2
};
Ordered_Dish J = new Ordered_Dish {
get_dish_id = 10, Get_D_Order_code = 39, get_quantity = 15
};
test.add_ordered_d(A);
test.add_ordered_d(B);
test.add_ordered_d(C);
test.add_ordered_d(D);
test.add_ordered_d(E);
test.add_ordered_d(F);
test.add_ordered_d(G);
test.add_ordered_d(H);
test.add_ordered_d(I);
test.add_ordered_d(J);
List <int> list_dish_b = new List <int>(); // basic
list_dish_b.Add(salad.Get_Dish_id);
list_dish_b.Add(bread.Get_Dish_id);
List <int> list_dish_g = new List <int>(); // glat
list_dish_g.Add(shnitzal.Get_Dish_id);
list_dish_g.Add(tost.Get_Dish_id);
list_dish_g.Add(melauach.Get_Dish_id);
List <int> list_dish_m = new List <int>(); // mehadrin
list_dish_m.Add(tiras.Get_Dish_id);
list_dish_m.Add(chicken.Get_Dish_id);
list_dish_m.Add(chips.Get_Dish_id);
list_dish_m.Add(ravioly.Get_Dish_id);
list_dish_m.Add(shawarma.Get_Dish_id);
Branch a = new Branch {
Get_name = "tovale", Get_add = "lala", Get_Branch_id = 60, Get_emp = 6, Get_emp_a = 6, Get_kosher = Supervision.Basic, get_location = Location.Center, get_menu = list_dish_b
};
Branch b = new Branch {
Get_name = "musaka", Get_add = "ababa", Get_Branch_id = 61, Get_emp = 11, Get_emp_a = 11, Get_kosher = Supervision.Glatt, get_location = Location.Judea_and_Samaria, get_menu = list_dish_g
};
Branch c = new Branch {
Get_name = "tovli", Get_add = "dada", Get_Branch_id = 62, Get_emp = 15, Get_emp_a = 15, Get_kosher = Supervision.Mehadrin, get_location = Location.Jerusalem, get_menu = list_dish_m
};
Branch d = new Branch {
Get_name = "torat", Get_add = "picha", Get_Branch_id = 63, Get_emp = 15, Get_emp_a = 15, Get_kosher = Supervision.Mehadrin, get_location = Location.Jerusalem, get_menu = list_dish_m
};
test.add_branch(a);
test.add_branch(b);
test.add_branch(c);
test.add_branch(d);
Client ma = new Client {
get_age = 50, Get_Cus_id = 100, get_name = "Ma", get_phone = 054848, get_cus_lo = Location.Center, get_card = 0303030, get_member_b = true, get_add = "newzeland", get_email = "*****@*****.**"
};
Client Da = new Client {
get_age = 30, Get_Cus_id = 101, get_name = "Da", get_phone = 054868, get_cus_lo = Location.Jerusalem, get_card = 045630
};
Client ga = new Client {
get_age = 20, Get_Cus_id = 102, get_name = "ga", get_phone = 054548, get_cus_lo = Location.Judea_and_Samaria, get_card = 0306000
};
Client la = new Client {
get_age = 10, Get_Cus_id = 103, get_name = "la", get_phone = 0543438, get_cus_lo = Location.Center, get_card = 789055
};
Client ta = new Client {
get_age = 19, Get_Cus_id = 104, get_name = "ta", get_phone = 0543438, get_cus_lo = Location.North, get_card = 045630
};
test.add_client(ma);
test.add_client(Da);
test.add_client(ga);
test.add_client(la);
test.add_client(ta);
List <int> od_b = new List <int>();
od_b.Add(32);
List <int> od_g = new List <int>();
od_g.Add(30); od_g.Add(31);
List <int> od_m = new List <int>();
od_m.Add(33); od_m.Add(34);
Order Aa = new Order {
Get_Order_code = 200, Get_branch_id = 60, Get_client_id = 100, get_location = Location.Center, Get_time = DateTime.Now, get_list = od_b
};
Order Ba = new Order {
Get_Order_code = 201, Get_branch_id = 61, Get_client_id = 101, get_location = Location.Jerusalem, Get_time = DateTime.Now, get_list = od_m
};
Order Fa = new Order {
Get_Order_code = 202, Get_branch_id = 62, Get_client_id = 102, get_location = Location.Judea_and_Samaria, Get_time = DateTime.Now, get_list = od_g
};
Order Ra = new Order {
Get_Order_code = 203, Get_branch_id = 62, Get_client_id = 103, get_location = Location.Center, Get_time = DateTime.Now, get_list = od_b
};
Order Ea = new Order {
Get_Order_code = 204, Get_branch_id = 61, Get_client_id = 104, get_location = Location.Center, Get_time = DateTime.Now, get_list = od_b
};
test.add_order(Aa);
test.add_order(Ba);
test.add_order(Fa);
test.add_order(Ra);
test.add_order(Ea);
poo = test.client_order_history(100); // poo
goo = test.Brach_order_history(a); // goo
doo = test.available_b(Location.Center); // doo
soo = test.find_by_kosher(Supervision.Glatt); // soo
hoo = test.All_Calories(od_g); // hoo
koo = test.oreder_bill(Ea); // koo
zoo = test.Profits_by_location(); // zoo
loo = test.dish_Profits(); // loo
woo = test.time_Profits(); // woo
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("client_order_history");
foreach (var item in poo)
{
foreach (var items in item)
{
Console.WriteLine("dish: " + items.name + " quantity:" + items.number + " price: " + items.oo_number);
}
//Console.WriteLine("\n");
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("Brach_order_history");
foreach (var item in goo)
{
foreach (var items in item)
{
Console.WriteLine("dish: " + items.name + " quantity:" + items.number + " price: " + items.oo_number);
}
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("available_b");
foreach (var item in doo)
{
Console.WriteLine("branch id :" + item.Get_Branch_id + " location :" + item.get_location.ToString());
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("find_by_kosher");
foreach (var item in soo)
{
Console.WriteLine("branch id :" + item.Get_Branch_id + " location :" + item.get_location.ToString() + " kosher : " + item.Get_kosher.ToString());
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("All_Calories");
Console.WriteLine("cloriot: " + hoo);
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("oreder_bill");
Console.WriteLine("bill: " + koo);
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("Profits_by_location");
foreach (var item in zoo)
{
Console.WriteLine("location :" + item.local.ToString() + " profit : " + item.sum_p);
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("dish_Profits");
foreach (var item in loo)
{
Console.WriteLine("dish name :" + item.name.ToString() + " profit : " + item.sum_p + " quantity: " + item.sum_q);
}
Console.WriteLine("end");
/////////////////////////////////////////////////////////////////////////////
Console.WriteLine("time_Profits");
foreach (var item in woo)
{
Console.WriteLine("date:" + item.date.ToString() + " profit : " + item.sum_p);
}
Console.WriteLine("end");
///////////////////////////////////////////////////////////////////////////////////////////
///delegate run!!
// o_p();
if (true)
{
; // debugging test..
}
}
public static BranchInfo ToModel([NotNull] this Branch branch) =>
new BranchInfo
{
Id = branch.Name,
Name = branch.Name
};
private void RecordConflicts(Config.RepoReport repoReportData, Branch sourceBranch, Branch targetBranch, Commit lastCommit)
{
foreach (var conflict in repo.Index.Conflicts)
{
Logger.Log("Conflicted on branch " + sourceBranch.FriendlyName + " with branch " + targetBranch.FriendlyName + ": " + conflict.Ancestor.Path);
RecordConflict(
repoReportData,
conflict.Ours.Path,
sourceBranch.FriendlyName.Split('/').Last(),
targetBranch.FriendlyName.Split('/').Last(),
lastCommit.Author.Name,
lastCommit.Author.When);
}
}
public async Task <IActionResult> Edit([FromBody] Branch branch) => Ok(await branchServices.Edit(branch));
public bool Create(Branch branch)
{
return(_db.Create <Branch>(branch));
}
public Instruction VisitBranch(Branch branch)
{
throw new NotImplementedException();
}
public Branch SaveBranch(Branch branch, Guid idAccount)
{
branch.PersonOwner.IdAccount = idAccount;
branch.PersonAdministration.IdAccount = idAccount;
branch.StatusRegister = CStatusRegister.Active;
branch.IdAccount = idAccount;
branch.Country = null;
branch.Province = null;
branch.District = null;
branch.Parish = null;
branch.Sector = null;
if (branch.PersonAdministration.Id != Guid.Empty)
{
branch.PersonAdministration = null;
}
if (branch.PersonOwner.Id != Guid.Empty)
{
branch.PersonOwner = null;
}
branch.IdAccount = idAccount;
branch.StatusRegister = CStatusRegister.Active;
var stateRegister = Guid.Empty == branch.Id ? EntityState.Added : EntityState.Modified;
using (var transaction = Context.Database.BeginTransaction())
{
try
{
//Cuando el dueño es administrador y es un nuevo dueño
if (branch.IsAdministratorOwner == CBranch.Yes &&
(branch.IdPersonAdministrator == Guid.Empty || null == branch.IdPersonAdministrator))
{
var personOwner = branch.PersonOwner;
var secuencia = _sequenceBusiness.NextSequence(CPerson.SequenceCode, idAccount);
if (personOwner != null)
{
personOwner.Code = secuencia.ToString();
Context.Persons.Add(personOwner);
Context.SaveChanges();
branch.PersonOwner = null;
branch.PersonAdministration = null;
branch.IdPersonAdministrator = personOwner.Id;
branch.IdPersonOwner = personOwner.Id;
}
else
{
throw new ExceptionMardis("Error al insertar Persona");
}
}
Sequence nextSequence;
if (string.IsNullOrEmpty(branch.Code))
{
nextSequence = _sequenceBusiness.NextSequence(CBranch.SequenceCode, idAccount);
var returnCode = nextSequence.Initial + "-" + nextSequence.SequenceCurrent;
branch.Code = returnCode;
}
else
{
//Elimino los Branchustomers
_branchDao.DeleteBranchCustomers(branch.Id, idAccount);
}
if (branch.IdPersonAdministrator == Guid.Empty)
{
nextSequence = _sequenceBusiness.NextSequence(CPerson.SequenceCode, idAccount);
if (branch.PersonAdministration != null)
{
branch.PersonAdministration.Code = nextSequence.ToString();
}
}
if (branch.IdPersonOwner == Guid.Empty)
{
nextSequence = _sequenceBusiness.NextSequence(CPerson.SequenceCode, idAccount);
if (branch.PersonOwner != null)
{
branch.PersonOwner.Code = nextSequence.ToString();
}
}
Context.Branches.Add(branch);
Context.Entry(branch).State = stateRegister;
Context.SaveChanges();
transaction.Commit();
branch = GetOne(branch.Id, idAccount);
}
catch (Exception ex)
{
transaction.Rollback();
branch = null;
}
}
return(branch);
}
void Start()
{
duoCam = GetComponent <Branch>();
Duo = GameObject.Find("strandedDuo");
followTarget = Duo;
}
/// <summary>
/// Creates a new Octree.
/// </summary>
/// <param name="splitCount">How many leaves a branch can hold before it splits into sub-branches.</param>
/// <param name="region">The region that your Octree occupies, all inserted bounds should fit into this.</param>
public Octree(int splitCount, AxisAlignedBoundingBox region)
{
this.splitCount = splitCount;
root = CreateBranch(this, null, region);
}
private void updateBranchControls()
{
Branch branch = FractalManager.SelectedBranch;
removeBranchToolStripButton.Enabled = (branch != null);
removeBranchToolStripMenuItem.Enabled = (branch != null);
duplicateBranchToolStripButton.Enabled = (branch != null);
duplicateBranchToolStripMenuItem.Enabled = (branch != null);
invertBranchToolStripButton.Enabled = (branch != null);
invertBranchToolStripMenuItem.Enabled = (branch != null);
weightLabel.Visible = (branch != null);
weightSpinner.Visible = (branch != null);
colorWeightLabel.Visible = (branch != null);
colorWeightSpinner.Visible = (branch != null);
localizedCheckbox.Visible = (branch != null);
foreach (ComboBox db in variDropBoxes)
{
db.Visible = (branch != null);
}
foreach (DragSpin ds in variSpinners)
{
ds.Visible = (branch != null);
}
if (branch != null)
{
weightSpinner.SetValueStealth((double)branch.Weight);
colorWeightSpinner.SetValueStealth((double)branch.ColorWeight);
localizedCheckbox.CheckedChanged -= applyLocalized;
localizedCheckbox.Checked = branch.Localized;
localizedCheckbox.CheckedChanged += applyLocalized;
foreach (ComboBox db in variDropBoxes)
{
db.SelectedIndexChanged -= applyVariControls;
db.SelectedIndex = 0;
}
foreach (DragSpin ds in variSpinners)
{
ds.ValueChanged -= applyVariControls;
ds.Value = 0;
}
for (int i = 0; i < Math.Min(variControlCount, branch.Variations.Count); i++)
{
variDropBoxes[i].SelectedItem = Variation.Variations[branch.Variations[i].Index];
variSpinners[i].Value = branch.Variations[i].Weight;
}
foreach (ComboBox db in variDropBoxes)
{
db.SelectedIndexChanged += applyVariControls;
}
foreach (DragSpin ds in variSpinners)
{
ds.ValueChanged += applyVariControls;
}
}
}
public bool Update(Branch branch)
{
return(_db.Update <Branch>(branch));
}
public bool DeleteById(int branchId)
{
Branch branch1 = _db.Find <Branch>(B => B.BranchId == branchId);
return(_db.Delete <Branch>(branch1));
}
public bool Delete(Branch branch)
{
return(_db.Delete <Branch>(branch));
}
public IEnumerable <Branch> GetByFilter([FromQuery] Branch entity)
{
return(this._branchService.GetAllByFilter(entity));
}
/// <summary>
/// Gets the number of commits in the longest single path between the specified commit and the most distant
/// ancestor (inclusive) that set the version to the value at the tip of the <paramref name="branch"/>.
/// </summary>
/// <param name="branch">The branch to measure the height of.</param>
/// <param name="repoRelativeProjectDirectory">The repo-relative project directory for which to calculate the version.</param>
/// <returns>The height of the branch till the version is changed.</returns>
public static int GetVersionHeight(this Branch branch, string repoRelativeProjectDirectory = null)
{
return(GetVersionHeight(branch.Commits.First(), repoRelativeProjectDirectory));
}
public AskFoodView(Branch branch) : this()
{
Branch = branch;
}
public void VisitBranch(Branch branch)
{
throw new NotImplementedException();
}
public override string ToString()
{
return(Branch.ToString() + ' ' + AccountNumber.ToString());
}
public Instruction VisitBranch(Branch b)
{
b.Condition = b.Condition.Accept(eval);
return(b);
}
public async Task Delete(string projectKey, string repositorySlug, Branch branch)
{
string requestUrl = UrlBuilder.FormatRestApiUrl(MANAGE_BRANCHES, null, projectKey, repositorySlug);
await _httpWorker.DeleteWithRequestContentAsync(requestUrl, branch);
}
public void GiveSunlight(Branch branch)
{
branch.IsSunlit = true;
}
public frmAddCustomer(Branch branch, frmTransactions transactions)
{
InitializeComponent();
this.branch = branch;
this.transactions = transactions;
}
/// <summary>
/// Gets the number of commits in the longest single path between the specified branch's head and the most distant
/// ancestor (inclusive).
/// </summary>
/// <param name="branch">The branch to measure the height of.</param>
/// <param name="continueStepping">
/// A function that returns <c>false</c> when we reach a commit that should not be included in the
/// height calculation.
/// May be <c>null</c> to count the height to the original commit.
/// </param>
/// <returns>The height of the branch.</returns>
public static int GetHeight(this Branch branch, Func <Commit, bool> continueStepping = null)
{
return(GetHeight(branch.Commits.First(), continueStepping));
}
/// <summary>
///
/// </summary>
/// <param name="branchPerson"></param>
/// <param name="idAccount"></param>
/// <param name="iduser"></param>
/// <param name="option"></param>
/// <param name="campaign"></param>
/// <param name="statusStask"></param>
/// <param name="datestart"></param>
/// <returns></returns>
public Branch GuardarlocalesCreadoAPPPedido(Branch branchPerson, int idAccount, string iduser, int option, int campaign, int statusStask, DateTime datestart)
{
bool status = false;
Branch branch = null;
Person person = null;
#pragma warning disable CS0219 // La variable 'task' está asignada pero su valor nunca se usa
TaskCampaign task = null;
#pragma warning restore CS0219 // La variable 'task' está asignada pero su valor nunca se usa
try
{
//var rutas = branchPerson.Select(x => x.RUTAAGGREGATE).Distinct();
if (branchPerson.Id != 0)
{
Context.Branches.Update(branchPerson);
Context.SaveChanges();
}
//var _datainsert = branchPerson.Where(x => x.Id == Guid.Parse("00000000-0000-0000-0000-000000000000"));
if (branchPerson.Id == 0)
{
Context.Branches.Add(branchPerson);
Context.SaveChanges();
}
if (option.Equals(2))
{
TaskCampaign _modelTask = new TaskCampaign();
var IMEID = branchPerson.IMEI_ID.Split('-');
if (IMEID.Length > 0)
{
if (IMEID[0] != "0")
{
try
{
var idpollster = Context.Pollsters.Where(x => x.IMEI == IMEID[0] &&
(datestart >= x.Fecha_Inicio && datestart <= x.Fecha_Fin) &&
x.idaccount.ToString().ToUpper() == idAccount.ToString().ToUpper() &&
x.Status == CStatusRegister.Active
);
_modelTask.idPollster = idpollster.FirstOrDefault().Id;
}
catch (Exception e)
{
return(null);
throw;
}
}
}
_modelTask.IdAccount = idAccount;
_modelTask.IdBranch = branchPerson.Id;
_modelTask.IdCampaign = campaign;
_modelTask.IdMerchant = Guid.Parse(iduser);
_modelTask.IdStatusTask = statusStask;
_modelTask.Route = branchPerson.RUTAAGGREGATE;
_modelTask.DateCreation = DateTime.Now;
_modelTask.StartDate = datestart;
_modelTask.DateModification = DateTime.Now;
_modelTask.Code = branchPerson.Code;
_modelTask.ExternalCode = branchPerson.Code;
_modelTask.Description = "Tarea creada desde carga de rutas";
_modelTask.StatusMigrate = "M";
Context.TaskCampaigns.Add(_modelTask);
Context.SaveChanges();
}
return(branchPerson);
}
catch (Exception e)
{
return(null);
throw;
}
finally
{
status = true;
}
}
private static bool BranchesAlreadyMerged(List <string> mergedPairs, Branch sourceBranch, Branch targetBranch)
{
if (mergedPairs.Contains(targetBranch.CanonicalName + " <- " + sourceBranch.CanonicalName) ||
mergedPairs.Contains(sourceBranch.CanonicalName + " <- " + targetBranch.CanonicalName))
{
Logger.Log("Branches have already been compared - skipping...");
return(true);
}
return(false);
}
public CUPayment(Branch selectedBranch)
{
InitializeComponent();
init(selectedBranch);
}
public Instruction VisitBranch(Branch branch)
{
//$TODO: this may not be necessary once scanner-development is done.
return(new SideEffect(Constant.String(string.Format("cloned {0}", branch), StringType.NullTerminated(PrimitiveType.Char))));
}
/// <summary>
/// Branches need to terminate the current basic block and make links
/// to the 'true' and 'false' destinations.
/// </summary>
/// <param name="b"></param>
/// <returns></returns>
public bool VisitBranch(RtlBranch b)
{
// We don't know the 'then' block yet, as the following statements may chop up the block
// we're presently in. Back-patch in when the block target is obtained.
var branch = new Branch(b.Condition, new Block(blockCur.Procedure, "TMP!"));
Emit(branch, blockCur);
// The following statements may chop up the blockCur, so hang on to the essentials.
var proc = blockCur.Procedure;
RtlInstructionCluster ricDelayed = null;
if ((b.Class & RtlClass.Delay) != 0)
{
rtlStream.MoveNext();
ricDelayed = rtlStream.Current;
ric = ricDelayed;
}
var fallthruAddress = ric.Address + ric.Length;
var blockThen = BlockFromAddress(ric.Address, b.Target, proc, state.Clone());
var blockElse = FallthroughBlock(ric.Address, proc, fallthruAddress);
var branchingBlock = blockCur.IsSynthesized
? blockCur
: scanner.FindContainingBlock(ric.Address);
if ((b.Class & RtlClass.Delay) != 0 &&
ricDelayed.Instructions.Count > 0)
{
// Introduce stubs for the delay slot, but only
// if the delay slot isn't empty.
if ((b.Class & RtlClass.Annul) != 0)
{
EnsureEdge(proc, branchingBlock, blockElse);
}
else
{
Block blockDsF = null;
blockDsF = proc.AddBlock(branchingBlock.Name + "_ds_f");
blockDsF.IsSynthesized = true;
blockCur = blockDsF;
ProcessRtlCluster(ricDelayed);
EnsureEdge(proc, blockDsF, blockElse);
EnsureEdge(proc, branchingBlock, blockDsF);
}
Block blockDsT = proc.AddBlock(branchingBlock.Name + "_ds_t");
blockDsT.IsSynthesized = true;
blockCur = blockDsT;
ProcessRtlCluster(ricDelayed);
EnsureEdge(proc, blockDsT, blockThen);
branch.Target = blockDsT;
EnsureEdge(proc, branchingBlock, blockDsT);
}
else
{
branch.Target = blockThen; // The back-patch referred to above.
EnsureEdge(proc, branchingBlock, blockElse);
if (blockElse != blockThen)
{
EnsureEdge(proc, branchingBlock, blockThen);
}
else
{
proc.ControlGraph.AddEdge(branchingBlock, blockThen);
}
}
// Now, switch to the fallthru block and keep rewriting.
blockCur = blockElse;
return(true);
}
public async Task <IActionResult> Post(Branch branch)
{
return(Ok(await branchServices.PostBranch(branch)));
}
public BranchTest()
{
_branch = new Branch(null);
_revision = Revision.Number(3);
_laterRevision = Revision.Number(4);
}
/// <summary>
/// Push the specified branch to its tracked branch on the remote.
/// </summary>
/// <param name="network">The <see cref="Network"/> being worked with.</param>
/// <param name="branch">The branch to push.</param>
/// <param name="onPushStatusError">Handler for reporting failed push updates.</param>
/// <param name="credentials">Credentials to use for user/pass authentication.</param>
/// <exception cref="LibGit2SharpException">Throws if either the Remote or the UpstreamBranchCanonicalName is not set.</exception>
public static void Push(
this Network network,
Branch branch,
PushStatusErrorHandler onPushStatusError = null,
Credentials credentials = null)
{
network.Push(new[] { branch }, onPushStatusError, credentials);
}
