private void FinanceForm_Loaded(object sender, RoutedEventArgs e)
{
if (m_lstTemplate == null)
{
m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("利润表");
m_lstTemplate.Sort((a, b) =>
{
var x = long.Parse(a.b);
var y = long.Parse(b.b);
if (x > y)
{
return(1);
}
else if (x == y)
{
return(0);
}
else
{
return(-1);
}
});
}
SheetModel = SheetModel.DATA;
}
public async Task <SheetModel> ToModel(Sheet sheet)
{
// Load form input groups.
var formInputGroups = await _unitOfWork.SheetRepository.GetFormInputGroups(sheet.SheetId);
// Instantiate sheet model.
var sheetModel = new SheetModel
{
SheetId = sheet.SheetId,
UserId = sheet.UserId,
};
// Instantiate a form input group model for each form input group.
var formInputGroupModels = new List <FormInputGroupModel>();
foreach (var formInputGroup in formInputGroups)
{
// Convert form input group object to model.
var formInputGroupModel = await GetFormInputGroup(formInputGroup);
formInputGroupModels.Add(formInputGroupModel);
}
sheetModel.FormGroups = formInputGroupModels.AsEnumerable();
return(sheetModel);
}
protected override object SetUpMember(int index, object member)
{
SheetModel sheet = ((SheetModel)member);
SSSheetNetworkService service = null;
using (Synchronizer.Lock(m_Service.m_Slide.SyncRoot)) {
if (this.m_Service.GetSubmissionStyle() != SlideModel.StudentSubmissionStyle.Normal)
{
using (Synchronizer.Lock(sheet.SyncRoot)) {
if ((sheet.Disposition & SheetDisposition.Remote) == 0 && (sheet is RealTimeInkSheetModel))
{
if (this.m_Service.GetSubmissionStyle() == SlideModel.StudentSubmissionStyle.Shared)
{
Message.AddLocalRef(this.m_Service.GetSubmissionSlideGuid(), this.m_Service.m_Slide);
}
//System.Windows.Forms.MessageBox.Show( sheet.GetType().ToString() );
service = new SSRealTimeInkSheetNetworkService(this.m_Service.m_Sender,
this.m_Service.m_Presentation,
this.m_Service.m_Deck,
this.m_Service.m_Slide,
(RealTimeInkSheetModel)sheet,
this.m_Selector);
}
}
}
}
return(service);
}
public static SheetRenderer ForSheet(SlideDisplayModel display, SheetModel sheet)
{
// TODO: Make this pluggable by dynamically loading available renderers, mapped by the types they support.
if (sheet is InkSheetModel)
{
if (sheet is RealTimeInkSheetModel)
{
return(new RealTimeInkSheetRenderer(display, (RealTimeInkSheetModel)sheet));
}
else
{
return(new InkSheetRenderer(display, (InkSheetModel)sheet));
}
}
else if (sheet is ImageSheetModel)
{
return(new ImageSheetRenderer(display, (ImageSheetModel)sheet));
}
else if (sheet is TextSheetModel)
{
return(new TextSheetRenderer(display, (TextSheetModel)sheet));
}
else if (sheet is QuickPollSheetModel)
{
return(new QuickPollSheetRenderer(display, (QuickPollSheetModel)sheet));
}
else if (sheet is XPSPageSheetModel)
{
return(new XPSPageRenderer(display, (XPSPageSheetModel)sheet));
}
else
{
return(null);
}
}
public static Message RemoteForSheet(SheetModel sheet, SheetCollection collection)
{
SheetModel newModel = null;
if (sheet is ImageSheetModel)
{
newModel = sheet;
}
else if (sheet is RealTimeInkSheetModel)
{
using (Synchronizer.Lock(sheet.SyncRoot)) {
newModel = new RealTimeInkSheetModel(sheet.Id, sheet.Disposition | SheetDisposition.Remote, sheet.Bounds);
using (Synchronizer.Lock(newModel.SyncRoot))
((RealTimeInkSheetModel)newModel).CurrentDrawingAttributes = ((RealTimeInkSheetModel)sheet).CurrentDrawingAttributes;
}
}
else if (sheet is InkSheetModel)
{
newModel = sheet;
}
else if (sheet is TextSheetModel)
{
newModel = sheet;
}
else if (sheet is QuickPollSheetModel)
{
newModel = sheet;
}
else if (sheet is XPSPageSheetModel)
{
newModel = sheet;
}
return(SheetMessage.ForSheet(newModel, collection));
}
public static ExcelModel ConvertDictionaryToExcelModel(IEnumerable <Dictionary <string, object> > data,
ExcelExporterOptions options)
{
var sheetTitle = options.SheetTitle;
var excel = new ExcelModel {
Sheets = new List <SheetModel>()
};
var sheet = SheetModel.Create(sheetTitle);
excel.Sheets.Add(sheet);
var list = data.ToList();
var title = list.FirstOrDefault();
if (title == null)
{
return(excel);
}
var columns = title.Keys.Select((c, i) => new ExcelColumn
{
Order = i,
Title = c,
Type = typeof(string)
}).ToList();
sheet.Columns = AttachColumns(columns, options);
sheet.Rows = list;
return(excel);
}
/// <summary>
/// Update a sheet's properties.
/// </summary>
/// <param name="id">Sheet id of sheet being updated.</param>
/// <param name="sheetModel">Sheet model containing all properties to be updated.</param>
/// <returns>Sheet model of the sheet with updated properties.</returns>
public async Task <ActionResult <SheetModel> > UpdateSheet(Guid?id, SheetModel sheetModel)
{
if (ModelState.IsValid)
{
if (id == null)
{
return(BadRequest());
}
var identity = HttpContext.User.Identity as ClaimsIdentity;
var userId = Guid.Parse(identity.Claims.First(claim => claim.Type == "Id").Value);
sheetModel.SheetId = (Guid)id;
try
{
return(await _service.UpdateSheet(sheetModel, userId));
}
catch (SecurityException)
{
return(Unauthorized());
}
catch
{
return(BadRequest());
}
}
return(BadRequest());
}
public void SendSheetInformation(SheetModel sheet, SheetMessage.SheetCollection selector, Group receivers)
{
// TODO: Also pass the index so the sheet can be inserted into the correct index on the remote side.
Message message, deck, slide;
message = new PresentationInformationMessage(this.m_Presentation);
message.Group = receivers;
message.InsertChild(deck = new DeckInformationMessage(this.m_Deck));
deck.InsertChild(slide = new SlideInformationMessage(this.m_Slide));
Message sm = SheetMessage.RemoteForSheet(sheet, selector);
//if sm is null that means that the sheet is an instructor note and shouldn't be sent.
if (sm != null)
{
slide.InsertChild(sm);
}
using (Synchronizer.Lock(this.m_Slide.SyncRoot)) {
message.Tags = new MessageTags();
message.Tags.SlideID = this.m_Slide.Id;
}
if (sheet is ImageSheetModel && ((ImageSheetModel)sheet).Image != null)
{
using (Synchronizer.Lock(sheet.SyncRoot)) {
this.m_Sender.Send(message);
}
}
else
{
this.m_Sender.Send(message);
}
}
/// <summary>
/// Performs a deep copy of the given SheetModel.
/// If the given sheetmodel is not an InkSheet, then returns itself.
/// </summary>
/// <param name="s">The SheetModel to copy</param>
/// <returns>The given sheetmodel if not an InkSheetModel, otherwise a deep copy of the InkSheetModel</returns>
protected SheetModel InkSheetDeepCopyHelper(SheetModel s)
{
using (Synchronizer.Lock(s.SyncRoot)) {
InkSheetModel t;
// Only copy InkSheetModels
if (s is InkSheetModel)
{
if (s is RealTimeInkSheetModel)
{
// Make a deep copy of the SheetModel
t = new RealTimeInkSheetModel(Guid.NewGuid(), s.Disposition | SheetDisposition.Remote, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone());
using (Synchronizer.Lock(t.SyncRoot)) {
((RealTimeInkSheetModel)t).CurrentDrawingAttributes = ((RealTimeInkSheetModel)s).CurrentDrawingAttributes;
}
}
else
{
// Make a deep copy of the SheetModel
t = new InkSheetModel(Guid.NewGuid(), s.Disposition, s.Bounds, ((InkSheetModel)s).Ink.Clone());
}
// This is a new object so add it to the local references
Message.AddLocalRef(t.Id, t);
return(t);
}
}
return(s);
}
protected override object SetUpMember(int index, object member)
{
SheetModel sheet = ((SheetModel)member);
using (Synchronizer.Lock(sheet.SyncRoot)) {
// Don't create a network service for the sheet if it is remote,
// UNLESS this is a student submission slide in which case we're responsible for rebroadcasting its ink.
if ((sheet.Disposition & SheetDisposition.Remote) != 0 && (this.m_Service.m_Slide.Disposition & SlideDisposition.StudentSubmission) == 0)
{
return(null);
}
}
Group receivers = Group.AllParticipant;
if ((this.m_Service.m_Slide.Disposition & SlideDisposition.StudentSubmission) != 0)
{
receivers = Group.Submissions;
}
this.m_Service.SendSheetInformation(sheet, this.m_Selector, receivers);
SheetNetworkService service = SheetNetworkService.ForSheet(this.m_Service.m_Sender, this.m_Service.m_Presentation, this.m_Service.m_Deck, this.m_Service.m_Slide, sheet, this.m_Selector);
return(service);
}
private void FinanceForm_Loaded(object sender, RoutedEventArgs e)
{
if (m_lstTemplate == null)
{
m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("资产负债表");
}
var year = DataFactory.Instance.GetSystemProfileExecuter().GetInt(SystemProfileKey.CurrentYear);
var period = DataFactory.Instance.GetSystemProfileExecuter().GetInt(SystemProfileKey.CurrentPeriod);
var now = DateTime.Now;
if (now.Year == year && now.Month == period)
{
}
else
{
now = CommonUtils.CalcMaxPeriodDate(year, period);
}
if (m_filter == null)
{
m_filter = new Dictionary <string, object>();
m_filter.Add("beginYear", now.Year);
m_filter.Add("beginPeriod", now.Month);
m_filter.Add("endYear", now.Year);
m_filter.Add("endPeriod", now.Month);
}
SheetModel = SheetModel.DATA;
}
public async Task <SheetModel> Update(SheetModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var sheet = await Sheet.Factory.GetInstanceAsync(db, model.Id);
if (sheet.Name != model.Name)
{
sheet.Name = model.Name;
}
var kept = new HashSet <int>();
foreach (var fieldModel in model.Fields.Where(o => o.Id > 0))
{
kept.Add(fieldModel.Id);
var field = sheet.SheetFields.Single(o => o.Id == fieldModel.Id);
field.Value = fieldModel.Value;
}
foreach (var fieldModel in model.Fields.Where(o => o.Id == 0))
{
CreateField(db, sheet, fieldModel);
}
foreach (var field in sheet.SheetFields.Where(o => !kept.Contains(o.Id)))
{
sheet.SheetFields.Remove(field);
SheetField.Factory.Delete(db, field);
}
await db.SaveChangesAsync();
return(SheetModelUtils.GetModel(sheet));
}
}
public List <SheetModel> CreateModels()
{
var models = new List <SheetModel>();
foreach (var sheet in _sheets)
{
var worksheetpart = (WorksheetPart)_document.WorkbookPart.GetPartById(sheet.Id);
var worksheet = worksheetpart.Worksheet;
var sharedStringTablePart = _document.WorkbookPart.SharedStringTablePart;
var descriptionCell = worksheet.Descendants <Cell>().FirstOrDefault(c => c.CellReference.Value == "A1");
if (descriptionCell == null || string.IsNullOrWhiteSpace(GetValue(descriptionCell, sharedStringTablePart)))
{
continue;
}
var model = new SheetModel
{
TabbleEnName = sheet.Name,
TableDescription = GetValue(descriptionCell, sharedStringTablePart),
Entity = new List <EntityModel>(),
Mapping = new List <MappingModel>(),
Search = new List <SearchModel>(),
Enums = new List <EnumModel>()
};
CreateSubModels(worksheet, model.Entity, model.Mapping, model.Search, model.Enums, sharedStringTablePart);
models.Add(model);
}
return(models);
}
public static SheetMatch ForSheet(EventQueue sender, SheetModel src, SheetModel dst)
{
// FIXME: Create SheetNetworkService classes for sheets other than InkSheetModels.
if (src is RealTimeInkSheetModel)
{
return(new RealTimeInkSheetMatch(sender, (RealTimeInkSheetModel)src, (RealTimeInkSheetModel)dst));
}
else if (src is InkSheetModel)
{
return(new InkSheetMatch(sender, (InkSheetModel)src, (InkSheetModel)dst));
}
else if (src is ImageSheetModel)
{
return(null);
}
else if (src is TextSheetModel)
{
return(null);
}
else if (src is QuickPollSheetModel)
{
return(null);
}
else
{
return(null);
}
}
protected override void TearDownMember(int index, object member, object tag)
{
if (tag == null)
{
return;
}
SheetModel sheet = ((SheetModel)member);
Message message, deck, slide;
message = new PresentationInformationMessage(this.m_Service.m_Presentation);
message.InsertChild(deck = new DeckInformationMessage(this.m_Service.m_Deck));
deck.InsertChild(slide = new SlideInformationMessage(this.m_Service.m_Slide));
slide.InsertChild(new SheetRemovedMessage(sheet, this.m_Selector));
using (Synchronizer.Lock(this.m_Service.m_Slide.SyncRoot)) {
message.Tags = new MessageTags();
message.Tags.SlideID = this.m_Service.m_Slide.Id;
}
this.m_Service.m_Sender.Send(message);
((SheetNetworkService)tag).Dispose();
}
protected override object SetUpMember(int index, object member)
{
SheetModel sheet = ((SheetModel)member);
// Add the SheetMatch to the collection of matches
using (Synchronizer.Lock(sheet.SyncRoot)) {
using (Synchronizer.Lock(this.m_Owner.m_DestSlide.SyncRoot)) {
if (sheet is RealTimeInkSheetModel)
{
// Add the sheet
RealTimeInkSheetModel m = new RealTimeInkSheetModel(Guid.NewGuid(), sheet.Disposition, sheet.Bounds);
this.m_Owner.m_DestSlide.AnnotationSheets.Add(m);
// Add the sheet match
SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m);
this.m_Owner.m_SheetMatches.Add(toAdd);
}
else if (sheet is InkSheetModel)
{
// Add the sheet
InkSheetModel m = new InkSheetModel(Guid.NewGuid(), sheet.Disposition, sheet.Bounds);
this.m_Owner.m_DestSlide.AnnotationSheets.Add(m);
// Add the sheet match
SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m);
this.m_Owner.m_SheetMatches.Add(toAdd);
}
}
}
return(null);
}
public void CreateMusicPiece(string filename)
{
_score = MusicXmlParser.GetScore(filename);
Guide = new GuidesController(MidiController)
{
Score = _score, Piano = Piano, Sheet = SheetController
};
Sheet = SheetController.SheetModel;
//stop program from crashing when reloading musicpiece.
Sheet.Reset();
AddGreatStaffsToSheet();
AddMeasuresToGreatStaffs();
AddNotesToMeasures();
Guide.staffEndReached += staffEndReached;
Guide.GoToFirstStaff += GoToFirstStaff;
Guide.HoldPosition += this.HoldPosition;
MidiController.Guide = Guide;
KeyboardController.Guide = Guide;
}
private bool determineIfDisplay(SheetModel sm)
{
using (Synchronizer.Lock(this.m_SlideDisplay.SyncRoot)) {
using (Synchronizer.Lock(sm.SyncRoot)) {
return((sm.Disposition & this.m_SlideDisplay.SheetDisposition) != 0);
}
}
}
public StackPanel StandardSheet()
{
GreatStaffModel greatStaffModel = new GreatStaffModel();
Sheet = new SheetModel();
Sheet.GreatStaffModelList.Add(greatStaffModel);
return(Sheet.DrawSheet());
}
private void FinanceForm_Loaded(object sender, RoutedEventArgs e)
{
if (m_lstTemplate == null)
{
m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("利润表");
}
SheetModel = SheetModel.DATA;
}
protected SheetUndoService(UndoModel undo, DeckModel deck, SlideModel slide, SheetModel sheet)
{
this.m_Undo = undo;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Sheet.Changed["Bounds"].Add(new PropertyEventHandler(this.HandleSheetChanged));
}
/// <summary>
/// Construct the sheet model
/// </summary>
/// <param name="sender">The event queue for async event handling</param>
/// <param name="srcSheet">The source sheet model</param>
/// <param name="dstSheet">The destination sheet model</param>
/// <param name="selector">Unknown</param>
public SheetMatch(EventQueue sender, SheetModel srcSheet, SheetModel dstSheet /*, SheetMessage.SheetCollection selector*/)
{
this.m_Sender = sender;
this.m_SourceSheet = srcSheet;
this.m_DestSheet = dstSheet;
this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleBoundsChanged));
this.m_SourceSheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher);
}
public SSSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
}
/// <summary>
/// Handle the button being clicked
/// </summary>
/// <param name="args">The event args</param>
protected override void OnClick(EventArgs args)
{
if (this.m_Slide == null)
{
return;
}
using (Synchronizer.Lock(this.m_Slide.SyncRoot)) {
InkSheetModel inks = null;
// TODO: This code is duplicated in InkSheetAdapter. Extract to a "ActiveInkAnnotationSheet" property of the SlideModel.
// Find the *top-most* *local* InkSheetModel in the annotation layer.
for (int i = m_Slide.AnnotationSheets.Count - 1; i >= 0; i--)
{
SheetModel sheet = m_Slide.AnnotationSheets[i];
if ((sheet.Disposition & SheetDisposition.Remote) != 0)
{
continue;
}
if (sheet is InkSheetModel)
{
inks = ((InkSheetModel)sheet);
}
//else if (sheet is EditableSheetModel ) {
// ///only erase the sheet model if the user made it
// ///(i.e. it is editable. If this is sent from another
// ///person, don't erase it).
// EditableSheetModel edit_sheet = (EditableSheetModel)sheet;
// if (edit_sheet.IsEditable) {
// m_Slide.AnnotationSheets.Remove(sheet);
// }
//}
}
if (inks != null)
{
using (Synchronizer.Lock(inks.SyncRoot)) {
Strokes strokes = inks.Ink.Strokes;
using (Synchronizer.Lock(strokes.SyncRoot)) {
int[] ids = new int[inks.Ink.Strokes.Count];
for (int j = 0; j < strokes.Count; j++)
{
ids[j] = strokes[j].Id;
}
StrokesEventArgs sea = new StrokesEventArgs(ids);
inks.OnInkDeleting(sea);
inks.Ink.DeleteStrokes();
inks.OnInkDeleted(sea);
}
}
}
}
base.OnClick(args);
}
public SheetMessage(SheetModel sheet, SheetCollection collection) : base(sheet.Id)
{
this.AddLocalRef(sheet);
this.Disposition = sheet.Disposition;
this.SheetCollectionSelector = collection;
using (Synchronizer.Lock(sheet.SyncRoot)) {
this.Bounds = sheet.Bounds;
}
this.Height = sheet.Height;
}
protected override void TearDownMember(int index, object member, object tag)
{
if (tag == null)
{
return;
}
SheetModel sheet = ((SheetModel)member);
((SheetNetworkService)tag).Dispose();
}
public static Column FillColumn(SheetModel sheetDTO, Column column)
{
foreach (var row in sheetDTO.Rows)
{
var cell = row.Cells.FirstOrDefault(c => c.ColumnLetter == column.Name);
if (cell != null)
{
column.Cells.Add(cell);
}
}
return(column);
}
public SheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleBoundsChanged));
this.m_Sheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher);
}
public static ExcelModel ConvertObjectToExcelModel <TModel>(IEnumerable <TModel> data,
ExcelExporterOptions options)
{
var sheetTitle = options.SheetTitle;
var excel = new ExcelModel {
Sheets = new List <SheetModel>()
};
if (string.IsNullOrWhiteSpace(sheetTitle))
{
var classAttr = ExcelUtil.GetClassExportAttribute <TModel>();
sheetTitle = classAttr.Item1 == null ? sheetTitle : classAttr.Item1.Title;
}
var sheet = SheetModel.Create(sheetTitle);
excel.Sheets.Add(sheet);
var attrDict = ExcelUtil.GetPropertiesAttributesDict <TModel>();
var objKeysArray = attrDict.OrderBy(c => c.Value.ExcelTitleAttribute.Order).ToArray();
var columns = new List <ExcelColumn>();
for (var i = 0; i < objKeysArray.Length; i++)
{
var titleAttr = objKeysArray[i].Value.ExcelTitleAttribute;
var fontAttr = objKeysArray[i].Value.ExcelColumnFontAttribute;
var column = new ExcelColumn
{
Title = titleAttr.Title,
Type = objKeysArray[i].Key.PropertyType,
Order = i,
Font = fontAttr == null ? null : new Font(fontAttr.FontName, fontAttr.FontHeightInPoints, fontAttr.Color, fontAttr.IsBold),
};
columns.Add(column);
}
sheet.Columns = AttachColumns(columns, options);
foreach (var item in data.Where(c => c != null))
{
var row = new Dictionary <string, object>();
foreach (var column in objKeysArray)
{
var prop = column.Key;
row[column.Value.ExcelTitleAttribute.Title] = prop.GetValue(item, null);
}
sheet.Rows.Add(row);
}
return(excel);
}
public static Sheet MapToSheet(SheetModel sheetDTO)
{
var sheet = new Sheet();
int columnNumber = 0;
foreach (var row in sheetDTO.Rows)
{
sheet.Data[0].RowData.Add(MapToRowData(row));
sheet.Data[0].ColumnMetadata.Add(MapToColumnMetadata(sheetDTO.Columns[columnNumber]));
columnNumber++;
}
return(sheet);
}
