public void CreateOrUpdate(ImplementerBindingModel model)
{
using (var context = new AbstractSweetShopDatabase())
{
Implementer element = context.Implementers.FirstOrDefault(rec => rec.ImplementerFIO == model.ImplementerFIO && rec.Id != model.Id);
if (element != null)
{
throw new Exception("Уже есть исполнитель с таким ФИО!");
}
if (model.Id.HasValue)
{
element = context.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element == null)
{
throw new Exception("Исполнитель не найден");
}
}
else
{
element = new Implementer();
context.Implementers.Add(element);
}
element.ImplementerFIO = model.ImplementerFIO;
element.WorkingTime = model.WorkingTime;
element.PauseTime = model.PauseTime;
context.SaveChanges();
}
}
public void CreateOrUpdate(ImplementerBindingModel model)
{
Implementer tempImplementer = new Implementer {
Id = 1
};
bool isImplementerExist = false;
foreach (var implementer in source.Implementers)
{
if (implementer.Id >= tempImplementer.Id)
{
tempImplementer.Id = implementer.Id + 1;
}
else if (implementer.Id == model.Id)
{
tempImplementer = implementer;
isImplementerExist = true;
break;
}
}
if (isImplementerExist)
{
CreateModel(model, tempImplementer);
}
else
{
source.Implementers.Add(CreateModel(model, tempImplementer));
}
}
public void CreateOrUpdate(ImplementerBindingModel model)
{
Implementer tempImplementer = model.Id.HasValue ? null : new Implementer {
Id = 1
};
foreach (var implementer in source.Implementers)
{
if (implementer.ImplementerFIO == model.ImplementerFIO && implementer.Id != model.Id)
{
throw new Exception("Уже есть исполнитель с таким ФИО!");
}
if (!model.Id.HasValue && implementer.Id >= tempImplementer.Id)
{
tempImplementer.Id = implementer.Id + 1;
}
else if (model.Id.HasValue && implementer.Id == model.Id)
{
tempImplementer = implementer;
}
}
if (model.Id.HasValue)
{
if (tempImplementer == null)
{
throw new Exception("Элемент не найден");
}
CreateModel(model, tempImplementer);
}
else
{
model.Id = source.Implementers.Count + 1;
source.Implementers.Add(CreateModel(model, tempImplementer));
}
}
public static T CreateProxy <T>(this HubConnection connection)
{
var impl = new Implementer <T>();
bool isIProxy = typeof(IProxy).IsAssignableFrom(typeof(T));
if (isIProxy)
{
impl.Member(o => ((IProxy)o).Connection).Returns(connection);
}
foreach (var method in impl.Methods.Where(o => (typeof(T).IsInterface || o.IsVirtual) && !o.IsSpecialName && o.IsPublic && typeof(Task).IsAssignableFrom(o.ReturnType)))
{
var invokeMethod = ResolveInvokeMethod(method);
int invokeMethodParamCount = invokeMethod.GetParameters().Length;
impl.Member <object>(method).Callback(args =>
{
var invokeArgs = new object[invokeMethodParamCount];
invokeArgs[0] = connection;
invokeArgs[1] = method.Name;
for (int i = 0; i < args.Count; i++)
{
invokeArgs[i + 2] = args.Values.ElementAt(i);
}
return(invokeMethod.Invoke(null, invokeArgs));
});
}
return(impl.Finish());
}
private Implementer CreateModel(ImplementerBindingModel model, Implementer Implementer)
{
Implementer.ImplementerFIO = model.ImplementerFIO;
Implementer.WorkingTime = model.WorkingTime;
Implementer.PauseTime = model.PauseTime;
return(Implementer);
}
public void CreateOrUpdate(ImplementerBindingModel model)
{
Implementer element = source.Implementers.FirstOrDefault(rec =>
rec.ImplementerFIO == model.ImplementerFIO && rec.Id != model.Id);
if (element != null)
{
throw new Exception("Уже есть исполнитель с таким ФИО!");
}
if (model.Id.HasValue)
{
element = source.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element == null)
{
throw new Exception("Элемент не найден");
}
}
else
{
int maxId = source.Implementers.Count > 0 ? source.Implementers.Max(rec => rec.Id) : 0;
element = new Implementer {
Id = maxId + 1
};
source.Implementers.Add(element);
}
element.ImplementerFIO = model.ImplementerFIO;
element.WorkingTime = model.WorkingTime;
element.PauseTime = model.PauseTime;
}
static void Test1()
{
Console.WriteLine("----Test1");
Implementer i = new Implementer();
i.Combine <Implementer>();
Console.WriteLine("ok");
}
private ImplementerViewModel CreateViewModel(Implementer Implementer)
{
return(new ImplementerViewModel
{
Id = Implementer.Id,
ImplementerFIO = Implementer.ImplementerFIO,
WorkingTime = Implementer.WorkingTime,
PauseTime = Implementer.PauseTime
});
}
private void button_add_Click(object sender, EventArgs e)
{
var implementer = new Implementer
{
Id = Implementer == null?Guid.NewGuid() : Implementer.Id,
Name = textBox_name.Text,
ContactName = textBox_contactName.Text,
Phone = textBox_phone.Text
};
MongoRepositoryImplementers.Upsert(implementer);
Close();
}
public void Delete(ImplementerBindingModel model)
{
Implementer element = source.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element != null)
{
source.Implementers.Remove(element);
}
else
{
throw new Exception("Элемент не найден");
}
}
private EventsManager(ISaveLoad saveLoad, Implementer implementer)
{
if (saveLoad == null || implementer == null)
{
throw new ArgumentNullException();
}
SaveLoad = saveLoad;
Load();
groups.AddListener_OnModify(Save);
this.implementer = implementer;
UpdateOrCreateInvokerClass();
}
protected virtual ImplementedEventSource DoImplement(TypeDefinition template)
{
var targetType = CreateTargetType(template);
var implementer = new Implementer(Module, CreateEventSourceTemplate(template), targetType)
{
EmitGuardedTracers = EmitGuardedTracers
};
return(new TemplateBasedEventSource
{
Old = template,
New = targetType,
Methods = implementer.Implement()
});
}
public void Delete(ImplementerBindingModel model)
{
using (var context = new AbstractSweetShopDatabase())
{
Implementer element = context.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element != null)
{
context.Implementers.Remove(element);
context.SaveChanges();
}
else
{
throw new Exception("Исполнитель не найден");
}
}
}
internal ImplementedEventSource Implement(TypeDefinition type)
{
type.FindConstructor().Resolve().Attributes |= MethodAttributes.Public;
type.Attributes = type.Attributes
.Remove(TypeAttributes.Abstract)
.Add(TypeAttributes.Sealed);
var methods = new Implementer(module, new EventSourceTemplate(type, new AbstractClassBasedTypeDefs(type))).Implement();
return new ImplementedEventSource
{
Methods = methods,
New = type,
Old = type
};
}
public void CreateOrUpdate(ImplementerBindingModel model)
{
Implementer element = source.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element == null)
{
int maxId = source.Implementers.Count > 0 ? source.Implementers.Max(rec => rec.Id) : 0;
element = new Implementer {
Id = maxId + 1
};
source.Implementers.Add(element);
}
element.ImplementerFIO = model.ImplementerFIO;
element.WorkingTime = model.WorkingTime;
element.PauseTime = model.PauseTime;
}
void InitializeImplementer()
{
//find the Implementer default Path
string path = Application.dataPath;
var directories = Directory.GetDirectories(Application.dataPath, "EventsPlugin_NonEditor",
SearchOption.AllDirectories);
if (directories.Length > 0)
{
path = directories[0];
}
//initialize the Implementer
implementer = new ListsImplemntation(path, "EventsManager_EventInvoker", ".cs");
UpdateOrCreateInvokerClass();
}
internal static TData GenerateDataObject(object dataObject)
{
if (!typeof(TData).IsInterface)
{
throw new Exception($"{nameof(TData)} must be an interface type");
}
if (ImplDataCache == null)
{
var impl = new Implementer <TData>(dataObject.GetType());
foreach (var prop in impl.Properties)
{
if (prop.GetMethod != null)
{
impl.Getter(prop).Callback(o =>
{
var file = o["__data"] as ReadableDataFile;
return(file.GetNonGeneric(
type: prop.PropertyType,
key: prop.Name
));
});
}
if (prop.SetMethod != null)
{
impl.Setter(prop, (value, data) =>
{
var file = (ReadableWritableDataFile)data;
file?.SetNonGeneric(
type: prop.PropertyType,
key: prop.Name,
value);
});
}
}
ImplDataCache = impl.Finish();
}
return(ClassUtils.Copy(ImplDataCache, dataObject));
}
public void CreateOrUpdate(ImplementerBindingModel model)
{
using (var context = new SecureShopDatabase())
{
Implementer element = context.Implementers.FirstOrDefault(rec => rec.Id == model.Id);
if (element == null)
{
element = new Implementer();
context.Implementers.Add(element);
}
element.ImplementerFIO = model.ImplementerFIO;
element.WorkingTime = model.WorkingTime;
element.PauseTime = model.PauseTime;
context.SaveChanges();
}
}
/// <summary>
/// Creates a proxy type for this queue. If <typeparamref name="T"/> is an interface, every method
/// will be overriden to call <see cref="Call(string, Type, object[])"/>. If it isn't an interface,
/// all of its virtual or abstract methods will be overriden instead.
/// </summary>
/// <typeparam name="T">The type of the proxy to create</typeparam>
public T CreateProxy <T>()
{
CheckDisposed();
var impl = new Implementer <T>();
foreach (var item in impl.Methods.Where(o => o.DeclaringType == typeof(T)))
{
var returnType = item.ReturnType;
if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>))
{
returnType = returnType.GenericTypeArguments[0];
}
impl.Member(item).Callback(args =>
{
if (typeof(Task).IsAssignableFrom(item.ReturnType))
{
var callMethod = this
.GetType()
#if NETSTANDARD2_1 || NETCOREAPP3_0
.GetMethod("Call", 1, new[] { typeof(string), typeof(object[]) })
#else
.GetMethods()
.Single(o => o.ContainsGenericParameters && o
.GetParameters()
.Select(o => o.ParameterType)
.SequenceEqual(new[] { typeof(string), typeof(object[]) }))
#endif
.MakeGenericMethod(returnType);
return(callMethod.Invoke(this, new object[] { item.Name, args.Values.ToArray() }));
}
else
{
return(Call(item.Name, returnType, args.Values.ToArray()).Result);
}
});
}
return(impl.Finish());
}
protected override void OnDetaching(EventArgs e)
{
Implementer.RemoveInterface(BaseType);
}
public override void Send(string msg)
{
//Console.WriteLine("RefinedAbstraction");
Implementer.SendMessage("UserMessage");
}
/// <exception cref="RelationException">
/// Cannot finalize relationship.
/// </exception>
protected override void OnAttaching(EventArgs e)
{
Implementer.AddInterface(BaseType);
}
public Abstraction(Implementer imp)
{
this.imp = imp;
}
public RefinedAbstraction(Implementer imp) : base(imp)
{
}
public override void Operation()
{
Console.WriteLine("RefinedAbstraction:Operation()");
Implementer.OperationImplementation();
}
public ImplementerForm(Implementer implementer = null)
{
Implementer = implementer;
InitializeComponent();
}
